Pull in Viget posts

content/elsewhere/functional-programming-in-ruby-with-contracts/index.md

@@ -0,0 +1,121 @@
+---
+title: "Functional Programming in Ruby with Contracts"
+date: 2015-03-31T00:00:00+00:00
+draft: false
+needs_review: true
+canonical_url: https://www.viget.com/articles/functional-programming-in-ruby-with-contracts/
+---
+
+I read Thomas Reynolds' [*My Weird
+Ruby*](http://awardwinningfjords.com/2015/03/03/my-weird-ruby.html) a
+week or two ago, and I **loved** it. I'd never heard of the
+[Contracts](https://github.com/egonSchiele/contracts.ruby) gem, but
+after reading the post and the [well-written
+docs](http://egonschiele.github.io/contracts.ruby/), I couldn't wait to
+try it out. I'd been doing some functional programming as part of our
+ongoing programming challenge series, and saw an opportunity to use
+Contracts to rewrite my Ruby solution to the [One-Time
+Pad](https://viget.com/extend/otp-a-language-agnostic-programming-challenge)
+problem. Check out my [rewritten `encrypt`
+program](https://github.com/vigetlabs/otp/blob/master/languages/Ruby/encrypt):
+
+     #!/usr/bin/env ruby
+
+    require "contracts"
+    include Contracts
+
+    Char = -> (c) { c.is_a?(String) && c.length == 1 }
+    Cycle = Enumerator::Lazy
+
+    Contract [Char, Char] => Num
+    def int_of_hex_chars(chars)
+     chars.join.to_i(16)
+    end
+
+    Contract ArrayOf[Num] => String
+    def hex_string_of_ints(nums)
+     nums.map { |n| n.to_s(16) }.join
+    end
+
+    Contract Cycle => Num
+    def get_mask(key)
+     int_of_hex_chars key.first(2)
+    end
+
+    Contract [], Cycle => []
+    def encrypt(plaintext, key)
+     []
+    end
+
+    Contract ArrayOf[Char], Cycle => ArrayOf[Num]
+    def encrypt(plaintext, key)
+     char = plaintext.first.ord ^ get_mask(key)
+     [char] + encrypt(plaintext.drop(1), key.drop(2))
+    end
+
+    plaintext = STDIN.read.chars
+    key = ARGV.last.chars.cycle.lazy
+
+    print hex_string_of_ints(encrypt(plaintext, key))
+
+Pretty cool, yeah? Compare with this [Haskell
+solution](https://github.com/vigetlabs/otp/blob/master/languages/Haskell/encrypt.hs).
+Some highlights:
+
+### Typechecking
+
+At its most basic, Contracts offers typechecking on function input and
+output. Give it the expected classes of the arguments and the return
+value, and you'll get a nicely formatted error message if the function
+is called with something else, or returns something else.
+
+### Custom types with lambdas {#customtypeswithlambdas}
+
+Ruby has no concept of a single character data type -- running
+`"string".chars` returns an array of single-character strings. We can
+simulate a native char type using a lambda, as seen on line #6, which
+says that the argument must be a string and must have a length of one.
+
+### Tuples
+
+If you're expecting an array of a specific length and type, you can
+specify it, as I've done on line #9.
+
+### Pattern matching {#patternmatching}
+
+Rather than one `encrypt` method with a conditional to see if the list
+is empty, we define the method twice: once for the base case (line #24)
+and once for the recursive case (line #29). This keeps our functions
+concise and allows us to do case-specific typechecking on the output.
+
+### No unexpected `nil` {#nounexpectednil}
+
+There's nothing worse than `undefined method 'foo' for nil:NilClass`,
+except maybe littering your methods with presence checks. Using
+Contracts, you can be sure that your functions aren't being called with
+`nil`. If it happens that `nil` is an acceptable input to your function,
+use `Maybe[Type]` à la Haskell.
+
+### Lazy, circular lists {#lazycircularlists}
+
+Unrelated to Contracts, but similarly inspired by *My Weird Ruby*, check
+out the rotating encryption key made with
+[`cycle`](http://ruby-doc.org/core-2.1.0/Enumerable.html#method-i-cycle)
+and
+[`lazy`](http://ruby-doc.org/core-2.1.0/Enumerable.html#method-i-lazy)
+on line #36.
+
+\* \* \*
+
+As a professional Ruby developer with an interest in strongly typed
+functional languages, I'm totally psyched to start using Contracts on my
+projects. While you don't get the benefits of compile-time checking, you
+do get cleaner functions, better implicit documentation, and more
+overall confidence about your code.
+
+And even if Contracts or FP aren't your thing, from a broader
+perspective, this demonstrates that **experimenting with other
+programming paradigms makes you a better programmer in your primary
+language.** It was so easy to see the utility and application of
+Contracts while reading *My Weird Ruby*, which would not have been the
+case had I not spent time with Haskell, OCaml, and Elixir.