LINUX.ORG.RU

История изменений

Исправление a--, (текущая версия) :

Чтобы «запустить» вычисление, в функцию нужно передать аргумент, который можно получить только выполнив предыдущее вычисление. Отсюда и получается, что все вычисления (и их эффекты) следуют строго друг за другом.

Это, похоже, чисто хаскелевская придумка, которая не имеет ничего общего с реальным положением дел.

Давай рассмотрим максимально простой случай, где монада = id:

b=f₁(f₂(f₃(f₄(a))))
Эта хрень параллелится на
g = λd: f₁(f₂(d))
c = f₃(f₄(a))
b = g(c)
Вообще говоря мы не умеем компактно считать g. Но в некоторых случаях вполне можем. Если например каждое fᵢ = λx: x~qᵢ где ~ опять-таки ассоциативная операция, то g = λd: (d~q₂)~q₁ ≡ λd: d~(q₂~q₁) вполне себе вычисляется.

В общем случае будет интересней, но возможности параллелизации опять могут быть. Можно рассмотреть монаду MayBe, натуральные числа qᵢ и операцию x~y которая (после лифтинга) дает Just(x+y), но при x+y>1000 дает Nothing. Вроде монада, я ничего не упустил?

Чуть подробнее:

T = множество натуральных чисел
M T = { Nothing, Just(1), ... , Just(1000) }
fᵢ = λx: x+qᵢ где qᵢ натуральные

unit(x) = Just(x) если x≤1000 иначе Nothing
bind(Just(x),fᵢ) = Just(x+qᵢ) если x+qᵢ≤1000 иначе Nothing
bind(Nothing,fᵢ) = Nothing

Там опять же можно параллелизовать так как написано выше.

Исправление a--, :

Чтобы «запустить» вычисление, в функцию нужно передать аргумент, который можно получить только выполнив предыдущее вычисление. Отсюда и получается, что все вычисления (и их эффекты) следуют строго друг за другом.

Это, похоже, чисто хаскелевская придумка, которая не имеет ничего общего с реальным положением дел.

Давай рассмотрим максимально простой случай, где монада = id:

b=f₁(f₂(f₃(f₄(a))))
Эта хрень параллелится на
g = λd: f₁(f₂(d))
c = f₃(f₄(a))
b = g(c)
Вообще говоря мы не умеем компактно считать g. Но в некоторых случаях вполне можем. Если например каждое fᵢ = λx: x~qᵢ где ~ опять-таки ассоциативная операция, то g = λd: (d~q₂)~q₁ ≡ λd: d~(q₂~q₁) вполне себе вычисляется.

В общем случае будет интересней, но возможности параллелизации опять могут быть. Можно рассмотреть монаду MayBe, натуральные числа qᵢ и операцию x~y которая (после лифтинга) дает Just(x+y), но при x+y>1000 дает Nothing. Вроде монада, я ничего не упустил?

Чуть подробнее:

T = множество натуральных чисел M T = { Nothing, Just(1), ... , Just(1000) } fᵢ = λx: x+qᵢ где qᵢ натуральные

unit(x) = Just(x) если x≤1000 иначе Nothing bind(Just(x),fᵢ) = Just(x+qᵢ) если x+qᵢ≤1000 иначе Nothing bind(Nothing,fᵢ) = Nothing

Там опять же можно параллелизовать так как написано выше.

Исправление a--, :

Чтобы «запустить» вычисление, в функцию нужно передать аргумент, который можно получить только выполнив предыдущее вычисление. Отсюда и получается, что все вычисления (и их эффекты) следуют строго друг за другом.

Это, похоже, чисто хаскелевская придумка, которая не имеет ничего общего с реальным положением дел.

Давай рассмотрим максимально простой случай, где монада = id:

b=f₁(f₂(f₃(f₄(a))))
Эта хрень параллелится на
g = λd: f₁(f₂(d))
c = f₃(f₄(a))
b = g(c)
Вообще говоря мы не умеем компактно считать g. Но в некоторых случаях вполне можем. Если например каждое fᵢ = λx: x~qᵢ где ~ опять-таки ассоциативная операция, то g = λd: (d~q₂)~q₁ ≡ λd: d~(q₂~q₁) вполне себе вычисляется.

В общем случае будет интересней, но возможности параллелизации опять могут быть. Можно рассмотреть монаду MayBe, натуральные числа qᵢ и операцию x~y которая (после лифтинга) дает Just(x+y), но при x+y>1000 дает Nothing. Вроде монада, я ничего не упустил?

Там опять же можно параллелизовать так как написано выше.

Исправление a--, :

Чтобы «запустить» вычисление, в функцию нужно передать аргумент, который можно получить только выполнив предыдущее вычисление. Отсюда и получается, что все вычисления (и их эффекты) следуют строго друг за другом.

Это, похоже, чисто хаскелевская придумка, которая не имеет ничего общего с реальным положением дел.

Давай рассмотрим максимально простой случай, где монада = id:

b=f₁(f₂(f₃(f₄(a))))
Эта хрень параллелится на
g = λd: f₁(f₂(d))
c = f₃(f₄(a))
b = g(c)
Вообще говоря мы не умеем компактно считать g. Но в некоторых случаях вполне можем. Если например каждое fᵢ = λx: x~qᵢ где ~ опять-таки ассоциативная операция, то g = λd: (d~q₂)~q₁ ≡ λd: d~(q₂~q₁) вполне себе вычисляется.

В общем случае будет интересней, но возможности параллелизации опять могут быть. Можно рассмотреть монаду MayBe, натуральные числа qᵢ и операцию x~y которая (после лифтинга) дает Just(x+y), но при x+y>1000 (допустим) дает Nothing. Вроде монада, я ничего не упустил?

Там опять же можно параллелизовать так как написано выше.

Исходная версия a--, :

Чтобы «запустить» вычисление, в функцию нужно передать аргумент, который можно получить только выполнив предыдущее вычисление. Отсюда и получается, что все вычисления (и их эффекты) следуют строго друг за другом.

Это, похоже, чисто хаскелевская придумка, которая не имеет ничего общего с реальным положением дел.

Давай рассмотрим максимально простой случай, где монада = id:

b=f₁(f₂(f₃(f₄(a))))
Эта хрень параллелится на
g = λd: f₁(f₂(d))
c = f₃(f₄(a))
b = g(c)
Вообще говоря мы не умеем компактно считать g. Но в некоторых случаях вполне можем. Если например каждое fᵢ = λx: x~qᵢ где ~ опять-таки ассоциативная операция, то g = λd: (d~q₂)~q₁ ≡ λd: d~(q₂~q₁) вполне себе вычисляется.

В общем случае будет интересней, но возможности параллелизации опять есть. Можно рассмотреть монаду MayBe, натуральные числа qᵢ и операцию x~y которая дает Just(x+y), но при x+y>1000 (допустим) дает Nothing. Вроде монада, я ничего не упустил?

Там опять же можно параллелизовать так как написано выше.