История изменений
Исправление a--, (текущая версия) :
Ты хочешь какую-то хрень... так вообще нельзя ничего доказать.
Дядя, а вы правда программист?
Если программист в чем-то уверен, то он не доказывает, а выставляет юнит-тесты и показывает, что они все проходятся.
«Хрень» это в первом приближении как раз юнит-тест (но во втором приближении там будут различия).
далеко не для всех монад можно реализовать сравнение
Да. Поэтому этот юнит-тест должен быть не в рамках программы, а путем сравнения нескольких выхлопов программы или даже выхлопов нескольких программ. Вот пример на c++, но должно быть на хаскеле. И еще тут пока что не монады!
#include <iostream>
#include <cstdlib>
int main(int argc, char** argv)
{
if( argc!=2 ) { std::cout << "usage: assoc_test choice\nwhere choice is 1...6\n"; return 1; }
int choice = atoi(argv[1]);
auto x = 70;
auto y = 80;
auto z = 90;
switch(choice)
{
case 1 : { auto L=x; auto R=y+z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 2 : { auto R=z; auto L=x+y; auto result=L+R; std::cout << result << "\n"; return 0; }
case 3 : { auto R=y+z; auto L=x; auto result=L+R; std::cout << result << "\n"; return 0; }
case 4 : { auto L=x+y; auto R=z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 5 : { auto result=x+(y+z); std::cout << result << "\n"; return 0; }
case 6 : { auto result=(x+y)+z; std::cout << result << "\n"; return 0; }
default: { std::cout << "incorrect input for choice: " << argv[1] << "\n"; return 2; }
}
}
В переводе на хаскель варианты 1,2,3,4 видимо пишутся через do для IO, варианты 5 и 6 через обычный вызов. ЕМНИП в с++ до сих пор операнды + могут считаться в произвольном порядке.
Я считаю операцию + ассоциативной для чисел 70,80,90, если для всех 6 вариантов исполнения программа выдаст одинаковый результат. Я считаю операцию + ассоциативной для целых, если для всех целых x,y,z (не только констант, но и читаемых снаружи) все 6 вариантов исполнения программы выдадут одинаковый результат.
Подозреваю, что ты считаешь, что ДЛЯ РЫБОК (т.е. для <=< и >=>) варианты 2 и 3 не обязаны давать тот же результат, что и остальные. Тогда я не согласен твою ассоциативность называть ассоциативностью, а скажем «секвенциальной ассоциативностью» (а чтобы было совсем обидно — так «слабой ассоциативностью»).
Почему так? Потому что с ассоциативностью кое-что можно параллелить, а со слабой ассоциативностью — уже нельзя.
И подозреваю, что часть хаскельных монад держат ассоциативность, а часть — только слабую ассоциативность.
Кстати — а как по-твоему: для обычных ассоциативных операций (т.е. исключая операции <=< и >=> и bind) варианты 2 и 3 должны давать тот же результат в хаскеле, что и 1,4,5,6 ?
Исправление a--, :
Ты хочешь какую-то хрень... так вообще нельзя ничего доказать.
Дядя, а вы правда программист?
Если программист в чем-то уверен, то он не доказывает, а выставляет юнит-тесты и показывает, что они все проходятся.
«Хрень» это в первом приближении как раз юнит-тест (но во втором приближении там будут различия).
далеко не для всех монад можно реализовать сравнение
Да. Поэтому этот юнит-тест должен быть не в рамках программы, а путем сравнения нескольких выхлопов программы или даже выхлопов нескольких программ. Вот пример на c++, но должно быть на хаскеле. И еще тут пока что не монады!
#include <iostream>
#include <cstdlib>
int main(int argc, char** argv)
{
if( argc!=2 ) { std::cout << "usage: assoc_test choice\nwhere choice is 1...6\n"; return 1; }
int choice = atoi(argv[1]);
auto x = 70;
auto y = 80;
auto z = 90;
switch(choice)
{
case 1 : { auto L=x; auto R=y+z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 2 : { auto R=z; auto L=x+y; auto result=L+R; std::cout << result << "\n"; return 0; }
case 3 : { auto R=y+z; auto L=x; auto result=L+R; std::cout << result << "\n"; return 0; }
case 4 : { auto L=x+y; auto R=z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 5 : { auto result=x+(y+z); std::cout << result << "\n"; return 0; }
case 6 : { auto result=(x+y)+z; std::cout << result << "\n"; return 0; }
default: { std::cout << "incorrect input for choice: " << argv[1] << "\n"; return 2; }
}
}
В переводе на хаскель варианты 1,2,3,4 видимо пишутся через do для IO, варианты 5 и 6 через обычный вызов. ЕМНИП в с++ до сих пор операнды + могут считаться в произвольном порядке.
Я считаю операцию + ассоциативной для чисел 70,80,90, если для всех 6 вариантов исполнения программа выдаст одинаковый результат. Я считаю операцию + ассоциативной для целых, если для всех целых x,y,z (не только констант, но и читаемых снаружи) все 6 вариантов исполнения программы выдадут одинаковый результат.
Подозреваю, что ты считаешь, что ДЛЯ МОНАД варианты 2 и 3 не обязаны давать тот же результат, что и остальные. Тогда я не согласен твою ассоциативность называть ассоциативностью, а скажем «секвенциальной ассоциативностью» (а чтобы было совсем обидно — так «слабой ассоциативностью»).
Почему так? Потому что с ассоциативностью кое-что можно параллелить, а со слабой ассоциативностью — уже нельзя.
И подозреваю, что часть хаскельных монад держат ассоциативность, а часть — только слабую ассоциативность.
Кстати — а как по-твоему: для обычных ассоциативных операций (т.е. исключая операции <=< и >=> и bind) варианты 2 и 3 должны давать тот же результат в хаскеле, что и 1,4,5,6 ?
Исправление a--, :
Ты хочешь какую-то хрень... так вообще нельзя ничего доказать.
Дядя, а вы правда программист?
Если программист в чем-то уверен, то он не доказывает, а выставляет юнит-тесты и показывает, что они все проходятся.
«Хрень» это в первом приближении как раз юнит-тест (но во втором приближении там будут различия).
далеко не для всех монад можно реализовать сравнение
Да. Поэтому этот юнит-тест должен быть не в рамках программы, а путем сравнения нескольких выхлопов программы или даже выхлопов нескольких программ. Вот пример на c++, но должно быть на хаскеле. И еще тут пока что не монады!
#include <iostream>
#include <cstdlib>
int main(int argc, char** argv)
{
if( argc!=2 ) { std::cout << "usage: assoc_test choice\nwhere choice is 1...6\n"; return 1; }
int choice = atoi(argv[1]);
auto x = 70;
auto y = 80;
auto z = 90;
switch(choice)
{
case 1 : { auto L=x; auto R=y+z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 2 : { auto R=z; auto L=x+y; auto result=L+R; std::cout << result << "\n"; return 0; }
case 3 : { auto R=y+z; auto L=x; auto result=L+R; std::cout << result << "\n"; return 0; }
case 4 : { auto L=x+y; auto R=z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 5 : { auto result=x+(y+z); std::cout << result << "\n"; return 0; }
case 6 : { auto result=(x+y)+z; std::cout << result << "\n"; return 0; }
default: { std::cout << "incorrect input for choice: " << argv[1] << "\n"; return 2; }
}
}
В переводе на хаскель варианты 1,2,3,4 видимо пишутся через do для IO, варианты 5 и 6 через обычный вызов. ЕМНИП в с++ до сих пор операнды + могут считаться в произвольном порядке.
Я считаю операцию + ассоциативной для чисел 70,80,90, если для всех 6 вариантов исполнения программа выдаст одинаковый результат. Я считаю операцию + ассоциативной для целых, если для всех целых x,y,z (не только констант, но и читаемых снаружи) все 6 вариантов исполнения программы выдадут одинаковый результат.
Подозреваю, что ты считаешь, что ДЛЯ МОНАД варианты 2 и 3 не обязаны давать тот же результат, что и остальные. Тогда я не согласен твою ассоциативность называть ассоциативностью, а скажем «секвенциальной ассоциативностью» (а чтобы было совсем обидно — так «слабой ассоциативностью»).
Кстати — а как по-твоему: для обычных ассоциативных операций (т.е. исключая операции <=< и >=> и bind) варианты 2 и 3 должны давать тот же результат в хаскеле, что и 1,4,5,6 ?
Почему так? Потому что с ассоциативностью кое-что можно параллелить, а со слабой ассоциативностью — уже нельзя.
И подозреваю, что часть хаскельных монад держат ассоциативность, а часть — только слабую ассоциативность.
Исправление a--, :
Ты хочешь какую-то хрень... так вообще нельзя ничего доказать.
Дядя, а вы правда программист?
Если программист в чем-то уверен, то он не доказывает, а выставляет юнит-тесты и показывает, что они все проходятся.
«Хрень» это в первом приближении как раз юнит-тест (но во втором приближении там будут различия).
далеко не для всех монад можно реализовать сравнение
Да. Поэтому этот юнит-тест должен быть не в рамках программы, а путем сравнения нескольких выхлопов программы или даже выхлопов нескольких программ. Вот пример на c++, но должно быть на хаскеле. И еще тут пока что не монады!
#include <iostream>
#include <cstdlib>
int main(int argc, char** argv)
{
if( argc!=2 ) { std::cout << "usage: assoc_test choice\nwhere choice is 1...6\n"; return 1; }
int choice = atoi(argv[1]);
auto x = 70;
auto y = 80;
auto z = 90;
switch(choice)
{
case 1 : { auto L=x; auto R=y+z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 2 : { auto R=z; auto L=x+y; auto result=L+R; std::cout << result << "\n"; return 0; }
case 3 : { auto R=y+z; auto L=x; auto result=L+R; std::cout << result << "\n"; return 0; }
case 4 : { auto L=x+y; auto R=z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 5 : { auto result=x+(y+z); std::cout << result << "\n"; return 0; }
case 6 : { auto result=(x+y)+z; std::cout << result << "\n"; return 0; }
default: { std::cout << "incorrect input for choice: " << argv[1] << "\n"; return 2; }
}
}
В переводе на хаскель варианты 1,2,3,4 видимо пишутся через do для IO, варианты 5 и 6 через обычный вызов. ЕМНИП в с++ до сих пор операнды + могут считаться в произвольном порядке.
Я считаю операцию + ассоциативной для чисел 70,80,90, если для всех 6 вариантов исполнения программа выдаст одинаковый результат. Я считаю операцию + ассоциативной для целых, если для всех целых x,y,z (не только констант, но и читаемых снаружи) все 6 вариантов исполнения программы выдадут одинаковый результат.
Подозреваю, что ты считаешь, что ДЛЯ МОНАД варианты 2 и 3 не обязаны давать тот же результат, что и остальные. Тогда я не согласен твою ассоциативность называть ассоциативностью, а скажем «секвенциальной ассоциативностью» (а чтобы было совсем обидно — так «слабой ассоциативностью»).
Кстати — а как по-твоему: для обычных операций (т.е. исключая операции <=< >=> и bind) варианты 2 и 3 должны давать тот же результат в хаскеле, что и 1,4,5,6 ?
Почему так? Потому что с ассоциативностью кое-что можно параллелить, а со слабой ассоциативностью — уже нельзя.
И подозреваю, что часть хаскельных монад держат ассоциативность, а часть — только слабую ассоциативность.
Исправление a--, :
Ты хочешь какую-то хрень... так вообще нельзя ничего доказать.
Дядя, а вы правда программист?
Если программист в чем-то уверен, то он не доказывает, а выставляет юнит-тесты и показывает, что они все проходятся.
«Хрень» это в первом приближении как раз юнит-тест (но во втором приближении там будут различия).
далеко не для всех монад можно реализовать сравнение
Да. Поэтому этот юнит-тест должен быть не в рамках программы, а путем сравнения нескольких выхлопов программы или даже выхлопов нескольких программ. Вот пример на c++, но должно быть на хаскеле. И еще тут пока что не монады!
#include <iostream>
#include <cstdlib>
int main(int argc, char** argv)
{
if( argc!=2 ) { std::cout << "usage: assoc_test choice\nwhere choice is 1...6\n"; return 1; }
int choice = atoi(argv[1]);
auto x = 70;
auto y = 80;
auto z = 90;
switch(choice)
{
case 1 : { auto L=x; auto R=y+z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 2 : { auto R=z; auto L=x+y; auto result=L+R; std::cout << result << "\n"; return 0; }
case 3 : { auto R=y+z; auto L=x; auto result=L+R; std::cout << result << "\n"; return 0; }
case 4 : { auto L=x+y; auto R=z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 5 : { auto result=x+(y+z); std::cout << result << "\n"; return 0; }
case 6 : { auto result=(x+y)+z; std::cout << result << "\n"; return 0; }
default: { std::cout << "incorrect input for choice: " << argv[1] << "\n"; return 2; }
}
}
В переводе на хаскель варианты 1,2,3,4 видимо пишутся через do для IO, варианты 5 и 6 через обычный вызов. ЕМНИП в с++ до сих пор операнды + могут считаться в произвольном порядке.
Я считаю операцию + ассоциативной для чисел 70,80,90, если для всех 6 вариантов исполнения программа выдаст одинаковый результат. Я считаю операцию + ассоциативной для целых, если для всех целых x,y,z (не только констант, но и читаемых снаружи) все 6 вариантов исполнения программы выдадут одинаковый результат.
Подозреваю, что ты считаешь, что ДЛЯ МОНАД варианты 2 и 3 не обязаны давать тот же результат, что и остальные. Тогда я не согласен твою ассоциативность называть ассоциативностью, а скажем «секвенциальной ассоциативностью» (а чтобы было совсем обидно — так «слабой ассоциативностью»).
Почему так? Потому что с ассоциативностью кое-что можно параллелить, а со слабой ассоциативностью — уже нельзя.
И подозреваю, что часть хаскельных монад держат ассоциативность, а часть — только слабую ассоциативность.
Исправление a--, :
Ты хочешь какую-то хрень... так вообще нельзя ничего доказать.
Дядя, а вы правда программист?
Если программист в чем-то уверен, то он не доказывает, а выставляет юнит-тесты и показывает, что они все проходятся.
«Хрень» это в первом приближении как раз юнит-тест (но во втором приближении там будут различия).
далеко не для всех монад можно реализовать сравнение
Да. Поэтому этот юнит-тест должен быть не в рамках программы, а путем сравнения нескольких выхлопов программы или даже выхлопов нескольких программ. Вот пример на c++, но должно быть на хаскеле. И еще тут пока что не монады!
#include <iostream>
#include <cstdlib>
int main(int argc, char** argv)
{
if( argc!=2 ) { std::cout << "usage: assoc_test choice\nwhere choice is 1...6\n"; return 1; }
int choice = atoi(argv[1]);
auto x = 70;
auto y = 80;
auto z = 90;
switch(choice)
{
case 1 : { auto L=x; auto R=y+z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 2 : { auto R=z; auto L=x+y; auto result=L+R; std::cout << result << "\n"; return 0; }
case 3 : { auto R=y+z; auto L=x; auto result=L+R; std::cout << result << "\n"; return 0; }
case 4 : { auto L=x+y; auto R=z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 5 : { auto result=x+(y+z); std::cout << result << "\n"; return 0; }
case 6 : { auto result=(x+y)+z; std::cout << result << "\n"; return 0; }
default: { std::cout << "incorrect input for choice: " << argv[1] << "\n"; return 2; }
}
}
В переводе на хаскель варианты 1,2,3,4 видимо пишутся через do для IO, варианты 5 и 6 через обычный вызов. ЕМНИП в с++ до сих пор операнды + могут считаться в произвольном порядке.
Я считаю операцию + ассоциативной для чисел 70,80,90, если для всех 6 вариантов исполнения программа выдаст одинаковый результат. Я считаю операцию + ассоциативной для целых, если для всех целых x,y,z (не только констант, но и читаемых снаружи) все 6 вариантов исполнения программы выдадут одинаковый результат.
Подозреваю, что ты считаешь, что варианты 2 и 3 не обязаны давать тот же результат, что и остальные. Тогда я не согласен твою ассоциативность называть ассоциативностью, а скажем «секвенциальной ассоциативностью» (а чтобы было совсем обидно — так «слабой ассоциативностью»).
Почему так? Потому что с ассоциативностью кое-что можно параллелить, а со слабой ассоциативностью — уже нельзя.
И подозреваю, что часть хаскельных монад держат ассоциативность, а часть — только слабую ассоциативность.
Исправление a--, :
Ты хочешь какую-то хрень... так вообще нельзя ничего доказать.
Дядя, а вы правда программист?
Если программист в чем-то уверен, то он не доказывает, а выставляет юнит-тесты и показывает, что они все проходятся.
«Хрень» это в первом приближении как раз юнит-тест (но во втором приближении там будут различия).
далеко не для всех монад можно реализовать сравнение
Да. Поэтому этот юнит-тест должен быть не в рамках программы, а путем сравнения нескольких выхлопов программы или даже выхлопов нескольких программ. Вот пример на c++, но должно быть на хаскеле. И еще тут пока что не монады!
#include <iostream>
#include <cstdlib>
int main(int argc, char** argv)
{
if( argc!=2 ) { std::cout << "usage: assoc_test choice\nwhere choice is 1...6\n"; return 1; }
int choice = atoi(argv[1]);
auto x = 70;
auto y = 80;
auto z = 90;
switch(choice)
{
case 1 : { auto L=x; auto R=y+z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 2 : { auto R=z; auto L=x+y; auto result=L+R; std::cout << result << "\n"; return 0; }
case 3 : { auto R=y+z; auto L=x; auto result=L+R; std::cout << result << "\n"; return 0; }
case 4 : { auto L=x+y; auto R=z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 5 : { auto result=x+(y+z); std::cout << result << "\n"; return 0; }
case 6 : { auto result=(x+y)+z; std::cout << result << "\n"; return 0; }
default: { std::cout << "incorrect input for choice: " << argv[1] << "\n"; return 2; }
}
}
В переводе на хаскель варианты 1,2,3,4 видимо пишутся через do для IO, варианты 5 и 6 через обычный вызов. ЕМНИП в с++ до сих пор операнды + могут считаться в произвольном порядке.
Я считаю операцию + ассоциативной для чисел 70,80,90, если для всех 6 вариантов исполнения программа выдаст одинаковый результат. Я считаю операцию + ассоциативной для целых, если для всех целых все 6 вариантов исполнения программы выдадут одинаковый результат.
Подозреваю, что ты считаешь, что варианты 2 и 3 не обязаны давать тот же результат, что и остальные. Тогда я не согласен твою ассоциативность называть ассоциативностью, а скажем «секвенциальной ассоциативностью» (а чтобы было совсем обидно — так «слабой ассоциативностью»).
Почему так? Потому что с ассоциативностью кое-что можно параллелить, а со слабой ассоциативностью — уже нельзя.
И подозреваю, что часть хаскельных монад держат ассоциативность, а часть — только слабую ассоциативность.
Исправление a--, :
Ты хочешь какую-то хрень... так вообще нельзя ничего доказать.
Дядя, а вы правда программист?
Если программист в чем-то уверен, то он не доказывает, а выставляет юнит-тесты и показывает, что они все проходятся.
«Хрень» это в первом приближении как раз юнит-тест (но во втором приближении там будут различия).
далеко не для всех монад можно реализовать сравнение
Да. Поэтому этот юнит-тест должен быть не в рамках программы, а путем сравнения нескольких выхлопов программы или даже выхлопов нескольких программ. Вот пример на c++, но должно быть на хаскеле. И еще тут пока что не монады!
#include <iostream>
#include <cstdlib>
int main(int argc, char** argv)
{
if( argc!=2 ) { std::cout << "usage: assoc_test choice\nwhere choice is 1...6\n"; return 1; }
int choice = atoi(argv[1]);
auto x = 70;
auto y = 80;
auto z = 90;
switch(choice)
{
case 1 : { auto L=x; auto R=y+z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 2 : { auto R=z; auto L=x+y; auto result=L+R; std::cout << result << "\n"; return 0; }
case 3 : { auto R=y+z; auto L=x; auto result=L+R; std::cout << result << "\n"; return 0; }
case 4 : { auto L=x+y; auto R=z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 5 : { auto result=x+(y+z); std::cout << result << "\n"; return 0; }
case 6 : { auto result=(x+y)+z; std::cout << result << "\n"; return 0; }
default: { std::cout << "incorrect input for choice: " << argv[1] << "\n"; return 2; }
}
}
В переводе на хаскель варианты 1,2,3,4 видимо пишутся через do для IO, варианты 5 и 6 через обычный вызов. ЕМНИП в с++ до сих пор операнды + могут считаться в произвольном порядке.
Я считаю операцию + ассоциативной для чисел 70,80,90, если для всех 6 вариантов исполнения программа выдаст одинаковый результат. Я считаю операцию + ассоциативной для целых, если для всех целых все 6 вариантов исполнения программы выдадут одинаковый результат.
Подозреваю, что ты считаешь, что варианты 2 и 3 не обязаны давать тот же результат, что и остальные. Тогда я не согласен твою ассоциативность называть ассоциативностью, а скажем «секвенциональной ассоциативностью» (а чтобы было совсем обидно — так «слабой ассоциативностью»).
Почему так? Потому что с ассоциативностью кое-что можно параллелить, а со слабой ассоциативностью — уже нельзя.
И подозреваю, что часть хаскельных монад держат ассоциативность, а часть — только слабую ассоциативность.
Исходная версия a--, :
Ты хочешь какую-то хрень... так вообще нельзя ничего доказать.
Дядя, а вы правда программист?
Если программист в чем-то уверен, то он не доказывает, а выставляет юнит-тесты и показывает, что они все проходятся.
«Хрень» это в первом приближении как раз юнит-тест (но во втором приближении там будут различия).
далеко не для всех монад можно реализовать сравнение
Да. Поэтому этот юнит-тест должен быть не в рамках программы, а путем сравнения нескольких выхлопов программы или даже выхлопов нескольких программ. Вот пример на c++, но должно быть на хаскеле. И еще тут пока что не монады!
#include <iostream>
#include <cstdlib>
int main(int argc, char** argv)
{
if( argc!=2 ) { std::cout << "usage: assoc_test choice\nwhere choice is 1...6\n"; return 1; }
int choice = atoi(argv[1]);
auto x = 70;
auto y = 80;
auto z = 90;
switch(choice)
{
case 1 : { auto L=x; auto R=y+z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 2 : { auto R=z; auto L=x+y; auto result=L+R; std::cout << result << "\n"; return 0; }
case 3 : { auto R=y+z; auto L=x; auto result=L+R; std::cout << result << "\n"; return 0; }
case 4 : { auto L=x+y; auto R=z; auto result=L+R; std::cout << result << "\n"; return 0; }
case 5 : { auto result=x+(y+z); std::cout << result << "\n"; return 0; }
case 6 : { auto result=(x+y)+z; std::cout << result << "\n"; return 0; }
default: { std::cout << "incorrect input for choice: " << argv[1] << "\n"; return 2; }
}
}
В переводе на хаскель варианты 1,2,3,4 видимо пишутся через do для IO, варианты 5 и 6 через обычный вызов. ЕМНИП в с++ до сих пор операнды + могут считаться в произвольном порядке.
Я считаю операцию + ассоциативной для чисел 70,80,90, если для всех 6 вариантов исполнения программа выдаст одинаковый результат. Я считаю операцию + ассоциативной для целых, если для всех целых все 6 вариантов исполнения программы выдадут одинаковый результат.
Подозреваю, что ты считаешь, что варианты 2 и 3 не обязаны давать тот же результат, что и остальные. Тогда я не согласен твою ассоциативность называть ассоциативностью, а скажем «секвенциональной ассоциативностью» (а чтобы было совсем обидно — так «слабой ассоциативностью»).
Почему так? Потому что с ассоциативностью кое-что можно параллелить, а со слабой ассоциативностью — уже нельзя.
И подозреваю, что часть хаскельных монад, держат ассоциативность, а часть — только слабую ассоциативность.