basics – redpanthers.co

Crystal tuples: the immutable data structure of crystal

coderhs — Wed, 06 Dec 2017 13:47:11 +0000

Tuple is a data structure which has immutable elements and is of a fixed size. Its similar to an array, but unlike arrays in crystal and ruby which allows adding more values over time a tuple is of fixed and cannot change. (Disclaimer: This article is meant for Ruby developer and explaining what a tuple is to a ruby developer). In crystal we have two types of tuple 1) Tuple {1, "hello", :world} 2) NamedTuple {x: 1, y:2, z: 5} They are immutable, which means if you try changing the value of an element in a tuple you will get an exception. Since crystal programs are compiled before execution you will get to see these errors while you compile the program itself. example:

x = {1, 2, 3}
# to get the value use
x[0]

If you try assigning a value to it, like so

x[0] = 10

You will get an exception like bellow.

undefined method '[]=' for Tuple(Int32, Int32)

In crsytal, tuples are the preferred way to return a multiple results from a method. For example inside the crystal core we have a method to get the minimum and maximum of an array.

(1..100).minmax

the result would be {1, 100}

Note: Since we just mentioned minmax, have a look at minmax_by method as well. It would let you apply a block of code over your range and then return the minimum and maximum based on the returned collection.
["1234", "12", "123"].minmax_by { |i| i.size }
# => {"12", "1234"}

Advantage of using tuple to return results instead of something like hash, is that we can be sure that our result cannot be altered accidentally. (since the data structure is immutable) ? You can build a tuple from an array by using the .from method

Tuple(Int32, Int32).from([1, 2])

As a developer, the place where we use tuple the most in crystal are with splats(symbol: *). Passing arguments to method using splat and double splat operator is something we use widely in ruby keep our code small and readable. So if you wish to do the same in crystal you need to make a tuple not a hash or array. If you use splat on an array directly like test(*[1,2]) it would return an error

argument to splat must be a tuple, not Array(Int32)

So to achieve the same effect as a splat with array in crystal we would need to do test(*{1,2})

Named Tuple

Named Tuple are everything as above, but with a name for each element. Named Tuple looks like {x: 1, y:2} it gives more meaning to our tuple. Like the above you can access the values but not change them.

data = {x: 1, y: 2}
# to get the value
data[:x]
# raises errors when we try to change it
data[:x] = 1

Double splats are meant for Named Tuple where in we can pass in the values for a particular argument using named tuple and double splat.

def print_date(year = nil, month = nil, day = nil)
  puts "#{year}/#{month}/#{day}"
end
birth_day = { year: 1990, month: 4, day: 3}
print_date(**birth_day)
card_expiry = { year: 2020, month: 1}
print_date(**card_expiry)

You can build a NamedTuple from a hash.

NamedTuple(name: String, val: String).from({"name" => "number", "val" => "Harisankar P S"}

Note: Crystal has a nifty feature called Union types (a variable can store data of multiple data types), so if it happen to pass such a variable to a named tuple/tuple, it will still check for the exact type that we want if the data is not in that variable then an exception would be raised Example

k = 42.as(Int32 | String)
NamedTuple(name: String, val: String).from({"name" => "number", "val" => K}

Exception:

cast from Int32 to String failed, at /usr/local/Cellar/crystal-lang/0.23.1_1/src/class.cr:41:5:41 (TypeCastError)
0x10e8f1085: *CallStack::unwind:Array(Pointer(Void)) at ??
0x10e8f1021: *CallStack#initialize:Array(Pointer(Void)) at ??
0x10e8f0ff8: *CallStack::new:CallStack at ??
0x10e8ec295: *raise:NoReturn at ??
0x10e90feb8: *String@Object::cast<(Int32 | String)>:String at ??
0x10e95faa3: *NamedTuple(name: String:Class, val: String:Class)@NamedTuple(T)#from:NamedTuple(name: String, val: String) at ??
0x10e95f787: *NamedTuple(name: String, val: String)@NamedTuple(T)::from:NamedTuple(name: String, val: String) at ??
0x10e8ef8a6: *__icr_exec__:NamedTuple(name: String, val: String) at ??
0x10e8db130: __crystal_main at ??
0x10e8ee578: main at ??

Extra Note:

If you put a splat before method argument and pass in arguments, they will be converted to a tuple

def a_method(*data)
  puts data
end
a_method(1,2,3)
#=> {1,2,3}

If you put a double splat before method argument and pass in data as keyword argument it gets converted to a NamedTuple

def a_method(**data)
  puts data
end
a_method(x: 1, y: 10)
#=> {x: 1, y: 10}

To summarize:

Tuples are immutable data structure
Regular tuple is like a frozen array
You can use splat only with a tuple
NamedTuple is like a frozen hash
Double splat can only be used with NamedTuple

]]>

Lambda vs Proc Vs Blocks

coderhs — Tue, 23 Aug 2016 09:45:09 +0000

Blocks: They are called closures in other languages, it is a way of grouping code/statements. In ruby single line blocks are written in {} and multi-line blocks are represented using do..end An interesting fact about ruby is that all methods in ruby accept a block, even if you don’t declare a variable to accept it. So for example, take the method below

def my_method
  puts "Hello World"
end

It can accept a block as below

my_method { puts 'Hello Reader' }

The code is valid, but the output will have only puts “Hello World”. Why? because we passed in the block but it is not getting called. To run the block passed within your method you need to use the yield command.

def my_method
  puts 'Hello World'
  yield
end

Now it will print

Hello World.
Hello Reader.

But since we placed yield, it would now be expecting a block to be always passed in. So we need to write code to check if a block is given or not. The command to do that in ruby is block_given?.

def my_method
  puts 'Hello World'
  yield if block_given?
end

Proc Is a block itself, but it’s bound to a variable. So proc lets us save a code block to a variable, and pass it around in our application. A good example from the ruby docs is shown below

def gen_times(factor)
  return Proc.new {|n| n*factor }
end
times3 = gen_times(3)
times5 = gen_times(5)
times3.call(12)               #=> 36
times5.call(5)                #=> 25
times3.call(times5.call(4))   #=> 60

Lambda If you felt proc’s to be a refined version of block, then you can say lambda’s to be a refined version of proc. Lambda is essentially a proc itself but, the argument management is rigid. If it doesn’t get an argument or if the argument count is more or less it would raise an error. Example:

Proc.new {|a,b| [a,b] }.call(1,2,3)
=> [1,2]

lambda {|a,b| [a,b] }.call(1,2,3)
=>
ArgumentError: wrong number of arguments (3 for 2)
	from (irb):7:in `block in irb_binding'
	from (irb):7:in `call'
	from (irb):7
	from /home/dev1/.rvm/rubies/ruby-2.2.2/bin/irb:11:in `'
2.2.2 :008 > Proc.new {|a,b| [a,b] }.call(1,2,3)

Since it’s now clearer to you on what block, proc and lambda is, let’s start with the difference between the three. Lambda shortcut notation.

code = -> (x) { x*x }
code.call 4
=> 16

Lambda vs proc vs Blocks Proc and Blocks are the same, block is actually creating a single instance of proc which can’t be moved about in a variable. You can read about the similarity of Proc and Block here. If we do return within a lambda, it would just return from lambda and the method will continue.

def lambda_method
  lambda { return puts 'lambda' }.call
  return 'method'
end
lambda_method
=> method

If we do return with a proc, it would exit the method and return that value from proc.

def proc_method
  Proc.new { return puts 'proc' }.call
  puts 'method'
end
proc_method
=> proc

Arguments: The second difference between the three is the way they manage arguments. Block and Proc deal with them more or less the same, but lambda is totally different. Proc and Bloc, doesn’t mind about the number of arguments passed. But if we access a variable that is not present then it would raise an error.

def my_method
  yield 1, 2, 3
end
my_method { |x, y| puts "#{x} & #{y}" }
=> "1 & 2"

Proc.new { |x, y| puts "#{x} & #{y}" }.call(4, 5, 6)
=> "4 & 5"

lambda will raise an error

def my_method
  yield
end
my_method { |x, y| puts "#{x} & #{y}" }

Takeaways Block, Proc & Lambda are the three different ways of grouping the code: Block:

Is in between the curly braces and in between do and end.
No issue with number of arguments.
Blocks are basically a proc without a name

Proc:

Similar behaviour as Block.
Can be stored in a variable and move around.
No issue with number of arguments.
Return within the proc would exit the method from where it is called.

Lambda

Same as Proc, but closer to a method.
Strict regarding the arguments it gets and it needs.
Return within a lambda would exit it from the lambda and the method would continue executing.

]]>