exxo blog

Сегодня я продолжу разговор, начатый здесь (пример про Гарды и калькулятор лишнего веса), и продолженный здесь (вычисление максимального числа из списка) и здесь (пример про максимум для произвольного списка). Все это касалось изучения функционального программирования по книге Learn You a Haskell for Great Good!

Функция replicate

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

Итак, Haskell:

    replicate :: (Num i, Ord i) => i -> a -> [a]  
    replicate n x  
        | n <= 0    = []  
        | otherwise = x:replicate (n-1) x

Как и в предыдущем примере, мы видим typeclass Ord, которого нет в Scala (но не в сторонних библиотеках).

Сперва напишем пример для целых чисел:

    def replicate(i:Int, x: Int):List[Int] = {
      i match {
        case n if n <= 0 => Nil
        case n => x::replicate(n-1, x)
      }
    }
    println(replicate(7, 9))

Но мы можем легко привести эту функцию к общему виду, заменив Int на Any:

    def replicate(i:, x: Any):List[Any] = {
      i match {
        case n if n <= 0 => Nil
        case n => x::replicate(n-1, x)
      }
    }

    println(replicate(12, 'a'))

Хотя правильнее будет записать это так:

    def replicate[A](i:, x: A):List[A] = {
      i match {
        case n if n <= 0 => Nil
        case n => x::replicate(n-1, x)
      }
    }

    println(replicate(12, 'a'))

Теперь функция будет работать с определенным типом, а не с Any.

 Функция take

Эта функция принимает число n и список l и возвращает другой список, содержащий первые n элементов списка  l.
Haskell:

    take :: (Num i, Ord i) => i -> [a] -> [a]  
    take n _  
        | n <= 0   = []  
    take _ []     = []  
    take n (x:xs) = x : take (n-1) xs  

В Scala это выглядит так:

    def take[A](n:Int, l:List[A]): List[A] = {
      (n, l) match {
        case (n, _) if n <= 0 => Nil
        case (_, Nil) => Nil
        case (n, x::xs) => x::take(n-1, xs)
      }
    }

    println(take(3, List(5, 34, 99, 8, 567, 222)))
    println(take(5, List("5", "34", "99", "8", "567", "222")))

Используется сравнение с образом (pattern matching):

• Если n равно или меньше нуля, мы получаем пустой лист.
• Если второй аргумент — пустой лист, то возвращается пустой лист.
• Если же второй аргумент список x::xs, то функция вызывается снова x::take(n-1, xs)

Функция reverse

Данная функция просто «переворачивает» список:

Haskell:

    reverse :: [a] -> [a]  
    reverse [] = []  
    reverse (x:xs) = reverse xs ++ [x]

Scala:

    def reverse[A](l: List[A]):List[A] = {
      l match {
        case Nil => Nil
        case x::xs => (reverse(xs) ::: x::Nil)
      }

    }

    println(reverse(1::2::3::4::4::5::6::7::Nil))

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

Я пришел в Scala из Java. Поэтому, когда я решил немного разобраться с такими библиотеками, как Scalaz или Cats, встал вопрос более глубокого изучении принципов функционального программирования. Лучшее, что я нашел, была книга Learn You a Haskell for Great Good!

Да, чтобы разобраться в функциональном программировании для Scala, пришлось познакомиться с совершенно новым для меня языком Haskell.

Чтобы лучше разбираться в написанном, я попутно «переводил» для себя некоторые примеры на Scala (по крайней мере, там где возникали какие-то аналогии).

На случай, если кто-то пойдет по моему пути, я решил поделиться своими результатами.

Guards, guards!

Первый пример из 4 главы посвящен использованию Гардов (сейчас лень искать русский аналог этого термина) в Haskell.

    bmiTell :: (RealFloat a) => a -> a -> String  
    bmiTell weight height  
        | weight / height ^ 2 <= 18.5 = "You're underweight, you emo, you!"  
        | weight / height ^ 2 <= 25.0 = "You're supposedly normal. Pffft, I bet you're ugly!"  
        | weight / height ^ 2 <= 30.0 = "You're fat! Lose some weight, fatty!"  
        | otherwise                 = "You're a whale, congratulations!"  

 

Здесь создается функция, которая вычисляет коэффициент BMI (используется для определения лишнего веса) с использованием гардов (guard). Если ваш BMI меньше 18.5, то вы излишне худы. Если от 18.5 до 25.0, то вес в норме. Если выше, то у вас лишний вес. А если больше 30, то вы — кит (так написано в первоисточнике).

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

Приблизительно вот так это выглядит в scala:

def rate(w:Int, h:Double):String = {
  val ratio = w/pow(h,2)
  ratio match {
    case r if r <= 18.5 => s"Underweight $r"
    case r if r <= 25 => s"Normal $r"
    case r if r <= 30 => s"Overweight! $r"
    case r => s"Whale! $r"

  }
}

println(rate(78, 1.76))

Похоже? По-моему, да. В Scala Гарды начинаются с ключевого слова if. А вместо otherwise используется паттерн без гарда. А так, код выглядит почти идентично.

Продолжение следует…