Сложим все вместе — конвертация валют (версия 3)

Давайте посмотрим, как мы могли бы вывести несколько валютных конверсий, используя блок кода:

methods_and_procs/curr_conv5.cr

base = "USD"

rates = {

"EUR" => 0.84320536,

"CAD" => 1.26761115,

"CNY" => 6.61591576,

}

full_names = {

"EUR" => "Euro",

"CAD" => "Canadian Dollar",

"CNY" => "Chinese Yuan",

}

 

# How much is 1 US Dollar?

output = "1 #{base} = \n" +                                 # (1)

rates.keys.map do |curr|                                   # (2)

"\t#{rates[curr]} #{full_names[curr]}s (#{curr})"

end.join("\n")                                                        # (3)

puts output

# 1 USD =

# 0.84320536 Euros (EUR)

# 1.26761115 Canadian Dollars (CAD)

# 6.61591576 Chinese Yuans (CNY)

  puts

# How much is 42 US Dollars?

amount = 42

output = "#{amount} #{base} = \n" +

rates.keys.map do |curr|

temp = sprintf("%3.2f", amount * rates[curr])      # (4)

"\t#{temp} #{full_names[curr]}s (#{curr})"

 

end.join("\n")

puts output

# 42 USD =

# 35.41 Euros (EUR)

# 53.24 Canadian Dollars (CAD)

# 277.87 Chinese Yuans (CNY)

 

(1) Начните со строки, где написано "output=".

(2) Добавьте к этой строке итог вычислений в блоке кода. Это итерация проведенная над массивом со всеми валютами, переданными через "rates.keys". Для каждой валюты map принимает блок кода, который выполняет вывод строки. Метод map создает новый массив с выводи-мыми строками для исходного массива (rates) с валютами.

(3) Соедините все элементы этого массива в одну общую строку с разделением элементов пустыми строками.

(4) Округлите выводимые числа до двух цифр после запятой, исполь-
зуя sprintf и строки формата %3.2f.

 

Ваш черёд № 2

Синтаксический сахар:

• Вычислите третью степень (возведение в куб) чисел от 1 до 10. (Подсказка: используйте **.)

• Сортируйте массив langs (из предыдущего примера) по размеру строк (Подсказка: использовать метод sort_by).

• Выполните обратную сортировку всех букв из названий языков в
langs. Результат должен быть: ["vaaJ", "oG", "ytsrlaC"]. (Подсказка: Используйте формирование цепочки — chaining.)

 

 

Иcпользование Procs

В предыдущем разделе вы видели, что захваченный блок кода (как вы помните — &block) фактически является объектом, называемым процедурой (Proc), или лямбда-функцией, или анонимной функцией; вы можете думать о Proc как о функциональном объекте с методом call. Знайте, что процедуры можно создавать с помощью нескольких различных подходов:

1) Двухсимвольная запись "->" позволяет создать литерал процедуры. Здесь вы запишете свой метод add для двух чисел как процедуру:

methods_and_procs/procs.cr

fn = ->(n: Int32, m: Int32) { n + m }

typeof(fn) # => Proc(Int32, Int32, Int32)

fn.call(42, 108) # => 150

Имя процедуры находится слева от знака =. Затем оператор "->" указывает список параметров. Предупреждаем, что здесь вам необ-
ходимо использовать типы. Дальше следует фрагмент кода между фигурных скобок {}. Во второй строке компилятор делает вывод относительно числового типа, возвращаемого процедурой.

2) Вы можете создать процедуру из существующего метода "add", используя аналогичную запись:

methods_and_procs/procs.cr

def add(n, m)

n + m

end

fn = ->add(Int32, Int32)

fn.call(42, 108) # => 150

3) Тот факт, что Proc является классом в стандартной библиотеке Кристалла, позволяет вам также использовать метод new:

methods_and_procs/procs.cr

fn = Proc(Int32, Int32, Int32).new { |n, m| n + m }

fn.call(42, 108) # => 150

Как и во многих других языках, процедуры могут работать как "замыкатели", здесь подразумевается, что они могут перехватить область контроля над переменными, которые использовались в момент создания этой процедуры. Вот как это работает на примере с процедурными литералами:

methods_and_procs/procs.cr

n = 42

fn = ->(m: Int32) { n + m }

fn.call(108) # => 150

n = 20

fn.call(108) # => 128

Нетрудно заметить — значение "n" известно внутри процедуры, и оно
так же верно опознается, когда переменной "n" придают иное значе-
ние. Захваченные блоки имеют схожее с переменными поведение:

methods_and_procs/procs.cr

def capture(&block: Int32 -> Int32)

block

end

 

 n = 42

 proc = capture { |m| n + m }

 proc.call(108) # => 150

n = 20

proc.call(108) # => 128

 

Это также демонстрирует, что захваченный блок может сопровождаться примечанием, описывающим типы данных: к примеру "Int32 -> Int32" означает, что число "Int32" будет принято в качестве параметра и возвращен будет тип Int32. Чтобы взять два таких параметра, следует написать: "Int32, Int32 -> Int32".

 

Ваш черёд № 3

ReturnProc: Напишите метод возрастания (incr), который инициализирует счетчик цифрой "ноль" и возвращает инкрементное значение посредством процедуры Proc. Напечатайте его тип и вызовите его несколько раз. Что происходит, когда вы даете методу новое имя и вызываете его с этим именем несколько раз?

Ваша голова не идет кругом? Всевозможные синтаксические
комбинации блоков кода и процедур иногда кажутся чрезвычайно избыточными. Но существуют и весьма находчивые решения, такие
как хранение процедуры в переменной экземпляра для имитации
обработчика событий (см. §"Определение обратных вызовов").

Вознаградите себя чашкой кофе или хорошим фильмом!