6 нежданчиков от Джулии

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

Второй выдал

DomainError with -1:
Cannot raise an integer x to a negative power -1.
Make x a float by adding a zero decimal (e.g., 2.0^-1 instead of 2^-1), or write 1/x^1, float(x)^-1, or (x//1)^-1

То есть, скорей всего возведение в отрицательную степень инта вынудило бы создавать переменную флоат, которую бы возвращали, а так разработчики нас вынуждают возводить вещественное число, чтоб вычисления можно было проводить непосредственно на нем.
(вспоминаю gotcha на С/С++ когда всё занулялось из-за деления на инт)

Короче, нежданчики будут везде, и хорошо быть предупрежденным.
А что на счет Julia, то я нашел её очень удобной: можно быстро набросать абстрактные вычисления, всё проверить, а потом ускорить, а то и скачать готовый пакет. Да и сам процесс кодинга приятен, но в моем случае это скорее страстное хобби

При выходе за границы будет ругаться, побочный эффект — замедление работы с массивом, это если хотите безопасности. А потом с помощью специальной приписки-макроса эту проверку можно убрать, и вот у нас опять производительность С

У программистов на императивных языках программирования есть привычка использовать избыточные конструкции. Однако в Julia можно многие из них не использовать. Например индексы массива. Очень часто они вообще не нужны. Либо индексы могут быть вычислены автоматически (без необходимости вспоминать, с нуля они начинаются или с единицы). Например, традиционный вариант цикла:

let res = 0
  x = [1:0.5:10...] # массив от 1 до 10 с шагом 0.5
  for i = 1 : length(x)
    res = res + 1 / x[i]
  end
  println(res) # 5.195479314287365
end

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

let res = 0
  x = [1:0.5:10...]
  for item in x
    res = res + 1 / item
  end
  println(res) # 5.195479314287365
end

Более того, мы же видим, что и цикл, в общем-то с точки зрения того, что требуется получить, является избыточным. Нас интересует результат свёртки массива по операции. Значит можем выразить эти действия лакончиным:

  x = [1:0.5:10...] 
  res = mapreduce(item -> 1/item, +, x)
  println(res) # 5.195479314287365

Имя метода здесь — mapreduce, значит аргументы им соответствют. Функция item -> 1/item относится к map. Функция + — к reduce.

Для случая простой свёртки без map, можем просто использовать reduce.

Если же действительно нужен индекс, то можно заставить Julia взять его самостоятельно.

let res = 0
  x = [1:0.5:10...]
  for i in eachindex(x)
    res = res + i / x[i]
  end
  println(res) # 32.80452068571264
end

Но в примере видим, что нас интересовал индекс и элемент, а не индекс для того, чтобы взять элемент. Значит можем заменить код:

let res = 0
  x = [1:0.5:10...]
  for (i, item) in enumerate(x)
    res = res + i / item
  end
  println(res) # 32.80452068571264
end

Но и в этом случае нас не просили писать цикл, а просили вычилить результат по каждому индексу и элементу. Значит, можем заменить на:

  x = [1:0.5:10...]
  res = mapreduce(((i, item),) -> i/item,  +,  enumerate(x))
  println(res) # 32.80452068571264

В последнем примере конструкция ((i, item),) указывает, что надо разобрать первый аргумент из tuple.