feed.xml

<?xml version="1.0" encoding="utf-8"?><feed xmlns="http://www.w3.org/2005/Atom" ><generator uri="https://jekyllrb.com/" version="4.3.3">Jekyll</generator><link href="/feed.xml" rel="self" type="application/atom+xml" /><link href="/" rel="alternate" type="text/html" /><updated>2024-07-31T20:05:38+00:00</updated><id>/feed.xml</id><title type="html">IQDevs</title><subtitle>Technology Excellence Redefined</subtitle><entry><title type="html">ZGPS - Achieving Abstraction with Golang</title><link href="/ZGPS-Achieving-Abstraction-with-Golang/" rel="alternate" type="text/html" title="ZGPS - Achieving Abstraction with Golang" /><published>2020-05-30T05:00:00+00:00</published><updated>2020-05-30T05:00:00+00:00</updated><id>/ZGPS%20-%20Achieving%20Abstraction%20with%20Golang</id><content type="html" xml:base="/ZGPS-Achieving-Abstraction-with-Golang/"><![CDATA[<p>One of the early design challenges we faced when designing the <code class="language-plaintext highlighter-rouge">DSP</code> (Device Service Provider) project is coming up with a plug-and-play architecture. <code class="language-plaintext highlighter-rouge">DSP</code>’s main responsibility is to read data from a specific tracking device, process and store the data, or send commands and process responses. Different devices come with different protocols, though they share common traits, like they all (all the ones we now support at least) are TCP based. Devices, when connected to <code class="language-plaintext highlighter-rouge">DSP</code>, are expected to be recognized so they’re handed to the proper protocol handler. Our silver bullet here is abstraction, but then we’re using Go, and Go doesn’t have native support for abstractions. So how do we solve this?</p>

<p>We came up with a list of functions every device –no matter how distinct– must support, and we created an interface called <code class="language-plaintext highlighter-rouge">DeviceProtocol</code> that encompasses all these functions. Our interface will include functions like <code class="language-plaintext highlighter-rouge">SetDeviceConnection</code>, <code class="language-plaintext highlighter-rouge">SetLogger</code>, <code class="language-plaintext highlighter-rouge">Read</code>, <code class="language-plaintext highlighter-rouge">Write</code>, <code class="language-plaintext highlighter-rouge">GetIMEI</code>, <code class="language-plaintext highlighter-rouge">SetUnit</code>, <code class="language-plaintext highlighter-rouge">Acknowledge</code>, <code class="language-plaintext highlighter-rouge">Reject</code>, <code class="language-plaintext highlighter-rouge">Handle</code>, <code class="language-plaintext highlighter-rouge">StoreRecord</code>, and <code class="language-plaintext highlighter-rouge">Disconnect</code>.</p>

<div class="language-go highlighter-rouge"><div class="highlight"><pre class="highlight"><code>
<span class="c">// DeviceProtocol is a set of functions all supports protocols need to implement.</span>
<span class="k">type</span> <span class="n">DeviceProtocol</span> <span class="k">interface</span> <span class="p">{</span>
	<span class="c">// SetDeviceConnection is called to hand the connection over to the device</span>
	<span class="c">// protocol instance. This is the first thing that happens once a new</span>
	<span class="c">// device is connected.</span>
	<span class="n">SetDeviceConnection</span><span class="p">(</span><span class="n">net</span><span class="o">.</span><span class="n">Conn</span><span class="p">)</span>

	<span class="c">// SetLogger keeps a copy of a provided Logger for the protocol to consume.</span>
	<span class="n">SetLogger</span><span class="p">(</span><span class="n">logger</span><span class="o">.</span><span class="n">Logger</span><span class="p">)</span>

	<span class="c">// Read allows the protocol to read a specified number of bytes directly</span>
	<span class="c">// from the device. Refer to the ReadParameters structure to find out</span>
	<span class="c">// and/or alter the capabilities of the Read function.</span>
	<span class="n">Read</span><span class="p">(</span><span class="n">ReadParameters</span><span class="p">)</span> <span class="p">(</span><span class="n">Buffer</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span>

	<span class="c">// Write allows the protocol to send byte streams directly to the device.</span>
	<span class="c">// If the number of bytes written does NOT comport with the number of bytes</span>
	<span class="c">// in the slice passed to the function, an error is returned.</span>
	<span class="n">Write</span><span class="p">([]</span><span class="kt">byte</span><span class="p">)</span> <span class="kt">error</span>

	<span class="c">// GetIMEI does what is necessary for the protocol to retrieve the IMEI from</span>
	<span class="c">// the device. Failures can be expected, and tend to be more occasional, then</span>
	<span class="c">// they need to be, so the caller needs to always watch out for errors. That</span>
	<span class="c">// is, if `error` is anything other than nil, the proper action is to reject</span>
	<span class="c">// the connection and bailout.</span>
	<span class="n">GetIMEI</span><span class="p">()</span> <span class="p">(</span><span class="kt">int64</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span>

	<span class="c">// Acknowledge is automatically called once an IMEI is retrieved and</span>
	<span class="c">// authenticated.</span>
	<span class="c">// NOTE: Units that are marked off as disabled in the database won't</span>
	<span class="c">// be acknowledged.</span>
	<span class="n">Acknowledge</span><span class="p">()</span> <span class="kt">error</span>

	<span class="c">// Reject is automatically called if the device fails to send an IMEI</span>
	<span class="c">// within a specified period of time, or if the IMEI is not found in</span>
	<span class="c">// the database or if the database object is marked off as disabled.</span>
	<span class="c">// This function is automatically called right before Disconnect is.</span>
	<span class="n">Reject</span><span class="p">()</span> <span class="kt">error</span>

	<span class="c">// SetUnit is called once a device is acknowledged. The point of this</span>
	<span class="c">// call is to hand over the Unit object to the protocol so that the</span>
	<span class="c">// protocol is capable of inferring the Unit identifier.</span>
	<span class="n">SetUnit</span><span class="p">(</span><span class="n">ms</span><span class="o">.</span><span class="n">Unit</span><span class="p">)</span>

	<span class="c">// Handle is the entry point to a device handler. Every supported protocol</span>
	<span class="c">// needs to implement this function. &lt;b&gt;No abstraction version of this</span>
	<span class="c">// function is provided&lt;/b&gt; for the sole reason that different devices</span>
	<span class="c">// come with different protocols.</span>
	<span class="n">Handle</span><span class="p">()</span> <span class="kt">error</span>

	<span class="c">// StoreRecord is responsible for processing one device Record at a time.</span>
	<span class="c">// Record (defined in Record.go) is supposed to at least have a Unit</span>
	<span class="c">// object (defined in ms/Unit.go) and a Position object (defined in</span>
	<span class="c">// ms/Position.go). Whether the Position is valid or not is decided by</span>
	<span class="c">// its own microservice later.</span>
	<span class="n">StoreRecord</span><span class="p">(</span><span class="o">*</span><span class="n">Record</span><span class="p">)</span> <span class="kt">error</span>

	<span class="c">// Disconnect is the last function called towards the end of the lifecycle</span>
	<span class="c">// of a protocol instance. That is, the function is called before the</span>
	<span class="c">// protocol instance is dismissed forever. Protocol lifecycle comes to an</span>
	<span class="c">// end when the device has been idle (no data received from a device within a</span>
	<span class="c">// designated timeframe), or if the device fails to send an IMEI or if the</span>
	<span class="c">// device IMEI is not associated with any Unit objects in the database, or</span>
	<span class="c">// if the Unit object is marked as disabled.</span>
	<span class="n">Disconnect</span><span class="p">()</span> <span class="kt">error</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Soon after a tracking device connects, we call <code class="language-plaintext highlighter-rouge">SetDeviceConnection</code> with our connection object, we then call <code class="language-plaintext highlighter-rouge">GetIMEI</code> that’ll internally compose a device identifier request and send it to the device using the <code class="language-plaintext highlighter-rouge">Write</code> function. The response is then retrieved with the <code class="language-plaintext highlighter-rouge">Read</code> function. Our <code class="language-plaintext highlighter-rouge">GetIMEI</code> function returns either the device unique identifier or an error (happens when the client fails to provide its IMEI within a designated timeframe, or when invalid data is provided or when the function identifies a suspicious activity).</p>

<p>A lot of these functions will have identical internal implementations. For instance,</p>
<ul>
  <li><code class="language-plaintext highlighter-rouge">SetDeviceConnection</code>, <code class="language-plaintext highlighter-rouge">SetLogger</code> and <code class="language-plaintext highlighter-rouge">SetUnit</code> are a common one-liner across all protocol implementations.</li>
  <li><code class="language-plaintext highlighter-rouge">Read</code> and <code class="language-plaintext highlighter-rouge">Write</code> will be identical across all protocols given Read is flexible with its <code class="language-plaintext highlighter-rouge">ReadParameters</code> and Write blindlessly transmits a given slice of bites. No device-specific intelligence required.</li>
  <li><code class="language-plaintext highlighter-rouge">StoreRecord</code> is a device-agnostic microservice-consuming function that doesn’t need to be reimplemented for every protocol.</li>
  <li><code class="language-plaintext highlighter-rouge">Disconnect</code> performs some Record-related actions (device-agnostic, remember?) and closes the TCP connection generically.</li>
</ul>

<p>The way around the issue is to have a form of abstraction that allows protocols to adopt at will and override when needed. Problem is Go isn’t an OOP language (that’s not to say OOP can’t be employed in the language), and so class abstraction isn’t a first-class construct of the language. What we do here is we create a <code class="language-plaintext highlighter-rouge">DeviceProtocolHeader</code> with our common functions defined and implemented, and aggregate the object in every protocol object we create:</p>

<div class="language-go highlighter-rouge"><div class="highlight"><pre class="highlight"><code>
<span class="c">// DeviceProtocolHeader has a set of abstract functions that device protocols tend to have</span>
<span class="c">// in common. Instead of having to re-implement the same errorprocedures for every</span>
<span class="c">// Protocol implementation, it is recommended to include this header and have</span>
<span class="c">// the extra functionality at no cost.</span>
<span class="k">type</span> <span class="n">DeviceProtocolHeader</span> <span class="k">struct</span> <span class="p">{</span>
	<span class="n">logger</span><span class="o">.</span><span class="n">Logger</span>
	<span class="n">client</span>     <span class="n">net</span><span class="o">.</span><span class="n">Conn</span>
	<span class="n">Unit</span>       <span class="n">ms</span><span class="o">.</span><span class="n">Unit</span>
	<span class="n">lastRecord</span> <span class="n">Record</span>
<span class="p">}</span>

<span class="c">// SetConnection ...</span>
<span class="k">func</span> <span class="p">(</span><span class="n">proto</span> <span class="o">*</span><span class="n">DeviceProtocolHeader</span><span class="p">)</span> <span class="n">SetDeviceConnection</span><span class="p">(</span><span class="n">client</span> <span class="n">net</span><span class="o">.</span><span class="n">Conn</span><span class="p">)</span> <span class="p">{</span>
	<span class="n">proto</span><span class="o">.</span><span class="n">client</span> <span class="o">=</span> <span class="n">client</span>

	<span class="c">// Set timeout to however many seconds ReadTimeout has.</span>
	<span class="n">readParams</span> <span class="o">:=</span> <span class="n">DefaultReadParameters</span><span class="p">()</span>
	<span class="n">proto</span><span class="o">.</span><span class="n">client</span><span class="o">.</span><span class="n">SetReadDeadline</span><span class="p">(</span><span class="n">time</span><span class="o">.</span><span class="n">Now</span><span class="p">()</span><span class="o">.</span><span class="n">Add</span><span class="p">(</span><span class="n">readParams</span><span class="o">.</span><span class="n">Timeout</span><span class="p">))</span>
<span class="p">}</span>

<span class="c">// SetLogger ...</span>
<span class="k">func</span> <span class="p">(</span><span class="n">proto</span> <span class="o">*</span><span class="n">DeviceProtocolHeader</span><span class="p">)</span> <span class="n">SetLogger</span><span class="p">(</span><span class="n">logger</span> <span class="n">logger</span><span class="o">.</span><span class="n">Logger</span><span class="p">)</span> <span class="p">{</span>
	<span class="n">proto</span><span class="o">.</span><span class="n">Logger</span> <span class="o">=</span> <span class="n">logger</span>
<span class="p">}</span>

<span class="c">// Read ...</span>
<span class="k">func</span> <span class="p">(</span><span class="n">proto</span> <span class="o">*</span><span class="n">DeviceProtocolHeader</span><span class="p">)</span> <span class="n">Read</span><span class="p">(</span><span class="n">params</span> <span class="n">ReadParameters</span><span class="p">)</span> <span class="p">(</span><span class="n">Buffer</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
	<span class="n">buf</span> <span class="o">:=</span> <span class="nb">make</span><span class="p">([]</span><span class="kt">byte</span><span class="p">,</span> <span class="n">params</span><span class="o">.</span><span class="n">ByteCount</span><span class="p">)</span>
	<span class="k">for</span> <span class="n">i</span> <span class="o">:=</span> <span class="m">0</span><span class="p">;</span> <span class="n">i</span> <span class="o">&lt;=</span> <span class="n">params</span><span class="o">.</span><span class="n">MaxTimeoutAttempts</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span> <span class="p">{</span>
		<span class="k">if</span> <span class="n">bufLen</span><span class="p">,</span> <span class="n">_</span> <span class="o">:=</span> <span class="n">proto</span><span class="o">.</span><span class="n">client</span><span class="o">.</span><span class="n">Read</span><span class="p">(</span><span class="n">buf</span><span class="p">);</span> <span class="n">bufLen</span> <span class="o">&gt;</span> <span class="m">0</span> <span class="p">{</span>
			<span class="k">return</span> <span class="n">Buffer</span><span class="p">{</span><span class="n">buf</span><span class="p">[</span><span class="o">:</span><span class="n">bufLen</span><span class="p">]},</span> <span class="no">nil</span>
		<span class="p">}</span>
		<span class="n">time</span><span class="o">.</span><span class="n">Sleep</span><span class="p">(</span><span class="n">params</span><span class="o">.</span><span class="n">Timeout</span><span class="p">)</span>
	<span class="p">}</span>
	<span class="k">return</span> <span class="n">Buffer</span><span class="p">{},</span> <span class="n">errors</span><span class="o">.</span><span class="n">New</span><span class="p">(</span><span class="s">"Device read timeout"</span><span class="p">)</span>
<span class="p">}</span>

<span class="c">// Write ...</span>
<span class="k">func</span> <span class="p">(</span><span class="n">proto</span> <span class="o">*</span><span class="n">DeviceProtocolHeader</span><span class="p">)</span> <span class="n">Write</span><span class="p">(</span><span class="n">data</span> <span class="p">[]</span><span class="kt">byte</span><span class="p">)</span> <span class="kt">error</span> <span class="p">{</span>
	<span class="k">if</span> <span class="n">bCount</span><span class="p">,</span> <span class="n">err</span> <span class="o">:=</span> <span class="n">proto</span><span class="o">.</span><span class="n">client</span><span class="o">.</span><span class="n">Write</span><span class="p">(</span><span class="n">data</span><span class="p">);</span> <span class="n">err</span> <span class="o">!=</span> <span class="no">nil</span> <span class="p">{</span>
		<span class="k">return</span> <span class="n">err</span>
	<span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="n">bCount</span> <span class="o">!=</span> <span class="nb">len</span><span class="p">(</span><span class="n">data</span><span class="p">)</span> <span class="p">{</span>
		<span class="k">return</span> <span class="n">fmt</span><span class="o">.</span><span class="n">Errorf</span><span class="p">(</span><span class="s">"Failed to write some or all bytes. Expected count: %d, written count: %d"</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">data</span><span class="p">),</span> <span class="n">bCount</span><span class="p">)</span>
	<span class="p">}</span>
	<span class="k">return</span> <span class="no">nil</span>
<span class="p">}</span>

<span class="c">// SetUnit ...</span>
<span class="k">func</span> <span class="p">(</span><span class="n">proto</span> <span class="o">*</span><span class="n">DeviceProtocolHeader</span><span class="p">)</span> <span class="n">SetUnit</span><span class="p">(</span><span class="n">unit</span> <span class="n">ms</span><span class="o">.</span><span class="n">Unit</span><span class="p">)</span> <span class="p">{</span>
	<span class="n">proto</span><span class="o">.</span><span class="n">Unit</span> <span class="o">=</span> <span class="n">unit</span>
<span class="p">}</span>

<span class="c">// StoreRecord ...</span>
<span class="k">func</span> <span class="p">(</span><span class="n">proto</span> <span class="o">*</span><span class="n">DeviceProtocolHeader</span><span class="p">)</span> <span class="n">StoreRecord</span><span class="p">(</span><span class="n">record</span> <span class="o">*</span><span class="n">Record</span><span class="p">)</span> <span class="kt">error</span> <span class="p">{</span>
	<span class="k">if</span> <span class="n">record</span> <span class="o">==</span> <span class="no">nil</span> <span class="p">{</span>
		<span class="k">return</span> <span class="n">errors</span><span class="o">.</span><span class="n">New</span><span class="p">(</span><span class="s">"Expected a Record. Received nil"</span><span class="p">)</span>
	<span class="p">}</span>

	<span class="n">record</span><span class="o">.</span><span class="n">Unit</span> <span class="o">=</span> <span class="n">proto</span><span class="o">.</span><span class="n">Unit</span>

	<span class="n">record</span><span class="o">.</span><span class="n">SetLogger</span><span class="p">(</span><span class="n">proto</span><span class="o">.</span><span class="n">Logger</span><span class="p">)</span>
	<span class="k">if</span> <span class="n">err</span> <span class="o">:=</span> <span class="n">record</span><span class="o">.</span><span class="n">Store</span><span class="p">();</span> <span class="n">err</span> <span class="o">!=</span> <span class="no">nil</span> <span class="p">{</span>
		<span class="k">return</span> <span class="n">err</span>
	<span class="p">}</span>

	<span class="k">if</span> <span class="n">record</span><span class="o">.</span><span class="n">Position</span><span class="o">.</span><span class="n">Timestamp</span><span class="o">.</span><span class="n">After</span><span class="p">(</span><span class="n">proto</span><span class="o">.</span><span class="n">lastRecord</span><span class="o">.</span><span class="n">Position</span><span class="o">.</span><span class="n">Timestamp</span><span class="p">)</span> <span class="p">{</span>
		<span class="c">// Prepare the last possible Record.</span>
		<span class="n">proto</span><span class="o">.</span><span class="n">lastRecord</span><span class="o">.</span><span class="n">Flags</span><span class="o">.</span><span class="n">Set</span><span class="p">(</span><span class="n">ms</span><span class="o">.</span><span class="n">Last</span><span class="p">)</span>
		<span class="n">proto</span><span class="o">.</span><span class="n">lastRecord</span><span class="o">.</span><span class="n">Unit</span> <span class="o">=</span> <span class="n">record</span><span class="o">.</span><span class="n">Unit</span>
		<span class="n">proto</span><span class="o">.</span><span class="n">lastRecord</span><span class="o">.</span><span class="n">Position</span> <span class="o">=</span> <span class="n">record</span><span class="o">.</span><span class="n">Position</span>
		<span class="n">proto</span><span class="o">.</span><span class="n">lastRecord</span><span class="o">.</span><span class="n">Position</span><span class="o">.</span><span class="n">ID</span> <span class="o">=</span> <span class="m">0</span>
		<span class="n">proto</span><span class="o">.</span><span class="n">lastRecord</span><span class="o">.</span><span class="n">Position</span><span class="o">.</span><span class="n">Speed</span> <span class="o">=</span> <span class="m">0</span>
		<span class="c">// NOTE: Modifying the last Record can be done here.</span>

		<span class="n">proto</span><span class="o">.</span><span class="n">Log</span><span class="p">(</span><span class="n">logger</span><span class="o">.</span><span class="n">INFO</span><span class="p">,</span> <span class="s">"Last known Position timestamp: %v"</span><span class="p">,</span> <span class="n">proto</span><span class="o">.</span><span class="n">lastRecord</span><span class="o">.</span><span class="n">Position</span><span class="o">.</span><span class="n">Timestamp</span><span class="p">)</span>
	<span class="p">}</span>

	<span class="k">return</span> <span class="no">nil</span>
<span class="p">}</span>

<span class="c">// Disconnect ...</span>
<span class="k">func</span> <span class="p">(</span><span class="n">proto</span> <span class="o">*</span><span class="n">DeviceProtocolHeader</span><span class="p">)</span> <span class="n">Disconnect</span><span class="p">()</span> <span class="kt">error</span> <span class="p">{</span>
	<span class="n">proto</span><span class="o">.</span><span class="n">client</span><span class="o">.</span><span class="n">Close</span><span class="p">()</span>
	<span class="k">if</span> <span class="n">proto</span><span class="o">.</span><span class="n">lastRecord</span><span class="o">.</span><span class="n">Flags</span><span class="o">.</span><span class="n">Has</span><span class="p">(</span><span class="n">ms</span><span class="o">.</span><span class="n">Last</span><span class="p">)</span> <span class="p">{</span>
		<span class="c">// Store last record. Whether this is a valid last trip or not</span>
		<span class="c">// is left for upper layers to decide.</span>
		<span class="k">if</span> <span class="n">err</span> <span class="o">:=</span> <span class="n">proto</span><span class="o">.</span><span class="n">StoreRecord</span><span class="p">(</span><span class="o">&amp;</span><span class="n">proto</span><span class="o">.</span><span class="n">lastRecord</span><span class="p">);</span> <span class="n">err</span> <span class="o">!=</span> <span class="no">nil</span> <span class="p">{</span>
			<span class="n">proto</span><span class="o">.</span><span class="n">Log</span><span class="p">(</span><span class="n">logger</span><span class="o">.</span><span class="n">ERROR</span><span class="p">,</span> <span class="s">"Error: %v"</span><span class="p">,</span> <span class="n">err</span><span class="p">)</span>
			<span class="k">return</span> <span class="n">err</span>
		<span class="p">}</span>
	<span class="p">}</span>
	<span class="k">return</span> <span class="no">nil</span>
<span class="p">}</span>

</code></pre></div></div>

<p>So, when introducing a new protocol object (say a proprietary ZGPS protocol), we do the following</p>

<div class="language-go highlighter-rouge"><div class="highlight"><pre class="highlight"><code>
<span class="k">type</span> <span class="n">ZGPS</span> <span class="k">struct</span> <span class="p">{</span>
    <span class="n">DeviceProtocolHeader</span>
<span class="p">}</span>

<span class="k">func</span> <span class="p">(</span><span class="n">proto</span> <span class="o">*</span><span class="n">ZGPS</span><span class="p">)</span> <span class="n">GetIMEI</span><span class="p">()</span> <span class="p">(</span><span class="kt">int64</span><span class="p">,</span> <span class="kt">error</span><span class="p">)</span> <span class="p">{</span>
    <span class="c">// TODO: Here goes our proprietary IMEI retrieval implementation</span>
<span class="p">}</span>

<span class="c">// Acknowledge ...</span>
<span class="k">func</span> <span class="p">(</span><span class="n">proto</span> <span class="o">*</span><span class="n">ZGPS</span><span class="p">)</span> <span class="n">Acknowledge</span><span class="p">()</span> <span class="kt">error</span> <span class="p">{</span>
    <span class="c">// TODO: Here goes our proprietery device/request acknowledgment implementation</span>
<span class="p">}</span>

<span class="c">// Reject ...</span>
<span class="k">func</span> <span class="p">(</span><span class="n">proto</span> <span class="o">*</span><span class="n">ZGPS</span><span class="p">)</span> <span class="n">Reject</span><span class="p">()</span> <span class="kt">error</span> <span class="p">{</span>
	<span class="c">// TODO: Here goes our proprietery device/request rejection implementation</span>
<span class="p">}</span>

<span class="c">// Handle ...</span>
<span class="k">func</span> <span class="p">(</span><span class="n">proto</span> <span class="o">*</span><span class="n">ZGPS</span><span class="p">)</span> <span class="n">Handle</span><span class="p">()</span> <span class="kt">error</span> <span class="p">{</span>
    <span class="c">// TODO: Here goes our proprietary data/request processing implementation</span>
<span class="p">}</span>

</code></pre></div></div>

<p>What have we objectively achieved here?</p>
<ol>
  <li>We’ve set ourselves up for a zero-duplication code base.</li>
  <li>We’ve added the ability to introduce higher-level system-wide business logic (take <code class="language-plaintext highlighter-rouge">lastRecord</code> for example) that future SMEs don’t even have to know about, making it easier to specialize at their own space.</li>
  <li>Bug hunting is now easier given the code is modularized yet cohesive, and fixes will often be made in one place.</li>
</ol>]]></content><author><name>Fadi Hanna Al-Kass</name></author><category term="Golang" /><summary type="html"><![CDATA[One of the early design challenges we faced when designing the DSP (Device Service Provider) project is coming up with a plug-and-play architecture. DSP’s main responsibility is to read data from a specific tracking device, process and store the data, or send commands and process responses. Different devices come with different protocols, though they share common traits, like they all (all the ones we now support at least) are TCP based. Devices, when connected to DSP, are expected to be recognized so they’re handed to the proper protocol handler. Our silver bullet here is abstraction, but then we’re using Go, and Go doesn’t have native support for abstractions. So how do we solve this?]]></summary></entry><entry><title type="html">Generic Types in Strongly Typed Languages</title><link href="/Generic-Types-in-Strongly-Typed-Languages/" rel="alternate" type="text/html" title="Generic Types in Strongly Typed Languages" /><published>2017-11-14T05:00:00+00:00</published><updated>2017-11-14T05:00:00+00:00</updated><id>/Generic%20Types%20in%20Strongly%20Typed%20Languages</id><content type="html" xml:base="/Generic-Types-in-Strongly-Typed-Languages/"><![CDATA[<p>Few days ago, I wrote <a href="https://github.com/alexcorvi/mongots">mongots</a>, an alternative API for <a href="https://www.mongodb.com/">MongoDB</a> to make it work better with <a href="https://www.typescriptlang.org/">TypeScript</a> (a strongly-typed language that compiles to JS) on the NodeJS environment.</p>

<p>“Alternative” is an overstatement, since it is totally built on top of the native MongoDB driver, and it’s not an ODM like <a href="http://mongoosejs.com/">Mongoose</a>, and it doesn’t provide any new functionality.</p>

<p>Then why did I write it? The answer is: “stronger types”. The native MongoDB driver has <a href="https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/mongodb">its type definitions in the DefinitelyTyped repository</a>, can be easily installed, but I was annoyed by all the <code class="language-plaintext highlighter-rouge">any</code> keywords it was littered with. It’s not that the authors don’t know how to make it more strongly typed, it’s just that MongoDB native driver API has been designed in a way (for JavaScript) that makes strong typing almost impossible with some cases.</p>

<p>My journey in creating this library has given me an insight on how generic types can be so helpful in some cases, and after seeing some tweets criticizing TypeScript’s generic types, I’ve decided to write this post.</p>

<p>Throughout this post, I’ll use TypeScript as an example, because everyone with a JavaScript background can comprehend the code, and personally, it’s my language of choice.</p>

<h2 id="introduction-to-generic-types">Introduction to Generic Types</h2>

<p>Let’s start with an example, a common pattern for JavaScript developers is to copy JSON objects using <code class="language-plaintext highlighter-rouge">JSON.stringify</code> and <code class="language-plaintext highlighter-rouge">JSON.parse</code>, like this:</p>

<div class="language-javascript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">function</span> <span class="nf">copyObject</span> <span class="p">(</span><span class="nx">obj</span><span class="p">)</span> <span class="p">{</span>
    <span class="kd">const</span> <span class="nx">string</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">stringify</span><span class="p">(</span><span class="nx">obj</span><span class="p">);</span>
    <span class="kd">const</span> <span class="nx">theCopy</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">parse</span><span class="p">(</span><span class="nx">string</span><span class="p">);</span>
    <span class="k">return</span> <span class="nx">theCopy</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p>The parameter <code class="language-plaintext highlighter-rouge">obj</code> in the above example can be anything, it can be a number, a string, an array, object literal …etc. So adding type definitions might be quite useless (without generic types):</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">function</span> <span class="nf">copyObject</span> <span class="p">(</span><span class="nx">obj</span><span class="p">:</span> <span class="kr">any</span><span class="p">):</span> <span class="kr">any</span> <span class="p">{</span>
    <span class="kd">const</span> <span class="kr">string</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">stringify</span><span class="p">(</span><span class="nx">obj</span><span class="p">);</span>
    <span class="kd">const</span> <span class="nx">theCopy</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">parse</span><span class="p">(</span><span class="kr">string</span><span class="p">);</span>
    <span class="k">return</span> <span class="nx">theCopy</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p>But with generic types, our function becomes as strongly typed as any function can be:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">function</span> <span class="nf">copyObject</span><span class="o">&lt;</span><span class="nx">T</span><span class="o">&gt;</span><span class="p">(</span><span class="nx">obj</span><span class="p">:</span> <span class="nx">T</span><span class="p">):</span> <span class="nx">T</span> <span class="p">{</span>
    <span class="kd">const</span> <span class="kr">string</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">stringify</span><span class="p">(</span><span class="nx">obj</span><span class="p">);</span>
    <span class="kd">const</span> <span class="nx">theCopy</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">parse</span><span class="p">(</span><span class="kr">string</span><span class="p">);</span>
    <span class="k">return</span> <span class="nx">theCopy</span><span class="p">;</span>
<span class="p">}</span>

<span class="kd">const</span> <span class="nx">myObject</span> <span class="o">=</span> <span class="p">{</span> <span class="na">a</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span> <span class="na">b</span><span class="p">:</span> <span class="mi">3</span> <span class="p">};</span>

<span class="kd">const</span> <span class="nx">theCopy</span> <span class="o">=</span> <span class="nf">copyObject</span><span class="p">(</span><span class="nx">myObject</span><span class="p">);</span>

<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nx">theCopy</span><span class="p">.</span><span class="nx">a</span><span class="p">);</span> <span class="c1">// OK!</span>
<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nx">theCopy</span><span class="p">.</span><span class="nx">b</span><span class="p">);</span> <span class="c1">// OK!</span>
<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nx">theCopy</span><span class="p">.</span><span class="nx">c</span><span class="p">);</span> <span class="c1">// Compile Error!</span>
</code></pre></div></div>

<p>The syntax for writing generic types is like many languages, before the parameters using the angle brackets.</p>

<p>Another example of how you can make use of generic types is when requesting data from a server.</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">function</span> <span class="nf">getFromServer</span><span class="o">&lt;</span><span class="nx">DataSchema</span><span class="o">&gt;</span><span class="p">(</span><span class="nx">url</span><span class="p">:</span> <span class="kr">string</span><span class="p">):</span> <span class="nx">Data</span> <span class="p">{</span>
    <span class="c1">// make the request</span>
    <span class="c1">// and return the data</span>
<span class="p">}</span>

<span class="kr">interface</span> <span class="nx">Employees</span> <span class="p">{</span>
    <span class="nl">departmentA</span><span class="p">:</span> <span class="kr">string</span><span class="p">[];</span>
    <span class="nl">departmentB</span><span class="p">:</span> <span class="kr">string</span><span class="p">[];</span>
<span class="p">};</span>

<span class="kd">const</span> <span class="nx">employees</span> <span class="o">=</span> <span class="nx">getFromServer</span><span class="o">&lt;</span><span class="nx">Employees</span><span class="o">&gt;</span><span class="p">(</span><span class="dl">"</span><span class="s2">http://www.example.com/api/employees.json</span><span class="dl">"</span><span class="p">);</span>

<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nx">employees</span><span class="p">.</span><span class="nx">departmentA</span><span class="p">);</span> <span class="c1">// OK!</span>
<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nx">employees</span><span class="p">.</span><span class="nx">departmentB</span><span class="p">);</span> <span class="c1">// OK!</span>
<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nx">employees</span><span class="p">.</span><span class="nx">departmentC</span><span class="p">);</span> <span class="c1">// Compile error!</span>
<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nx">employees</span><span class="p">.</span><span class="nx">departmentA</span><span class="p">.</span><span class="nx">length</span><span class="p">)</span> <span class="c1">// OK!</span>
<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nx">employees</span><span class="p">.</span><span class="nx">departmentA</span> <span class="o">+</span> <span class="nx">employees</span><span class="p">.</span><span class="nx">departmentB</span><span class="p">);</span>
<span class="c1">// ^ Compile errors because they are arrays</span>
</code></pre></div></div>

<p>The previous example shows how generic types are treated like additional arguments in the function. And that’s what they really are, <em>additional arguments</em>. In the first example, however, TypeScript was smart enough to determine the type of the passed value, and we did not need to pass any generic type values in angle brackets. Typescript can also be smart and notify you when you do something like this:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">function</span> <span class="nf">copyObject</span><span class="o">&lt;</span><span class="nx">T</span><span class="o">&gt;</span><span class="p">(</span><span class="nx">obj</span><span class="p">:</span> <span class="nx">T</span><span class="p">):</span> <span class="nx">T</span> <span class="p">{</span>
    <span class="kd">const</span> <span class="kr">string</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">stringify</span><span class="p">(</span><span class="nx">obj</span><span class="p">);</span>
    <span class="kd">const</span> <span class="nx">theCopy</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">parse</span><span class="p">(</span><span class="kr">string</span><span class="p">);</span>
    <span class="k">return</span> <span class="nx">theCopy</span><span class="p">;</span>
<span class="p">}</span>

<span class="kd">const</span> <span class="nx">myObject</span> <span class="o">=</span> <span class="p">{</span> <span class="na">a</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span> <span class="na">b</span><span class="p">:</span> <span class="mi">3</span> <span class="p">};</span>

<span class="kd">const</span> <span class="nx">theCopy</span> <span class="o">=</span> <span class="nx">copyObject</span><span class="o">&lt;</span><span class="kr">number</span><span class="o">&gt;</span><span class="p">(</span><span class="nx">myObject</span><span class="p">);</span>
<span class="c1">// ^ Compile Error:</span>
<span class="c1">// Argument of type '{ a: number; b: number; }'</span>
<span class="c1">// is not assignable to parameter of type 'number'.</span>
</code></pre></div></div>

<p>Now if you’re writing your server and your front end with typescript you don’t have to write the interface <code class="language-plaintext highlighter-rouge">Employees</code> twice, what you can do is structure your project in a way that the server (back-end) and the front-end share a directory where you keep type definitions.</p>

<p>So, in the types directory, you can have this file <code class="language-plaintext highlighter-rouge">interface.employee.ts</code></p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">export</span> <span class="kr">interface</span> <span class="nx">Employee</span> <span class="p">{</span>
    <span class="nl">name</span><span class="p">:</span> <span class="kr">string</span><span class="p">;</span>
    <span class="nl">birth</span><span class="p">:</span> <span class="kr">number</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p>In your server:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">import</span> <span class="p">{</span> <span class="nx">Employee</span> <span class="p">}</span> <span class="k">from</span> <span class="dl">"</span><span class="s2">../types/interface.employee.ts</span><span class="dl">"</span>
<span class="kd">const</span> <span class="nx">employeesCollection</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">myDB</span><span class="p">.</span><span class="nx">collection</span><span class="o">&lt;</span><span class="nx">Employee</span><span class="o">&gt;</span><span class="p">(</span><span class="dl">"</span><span class="s2">employees</span><span class="dl">"</span><span class="p">);</span>
</code></pre></div></div>

<p>And in your front end:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">import</span> <span class="p">{</span> <span class="nx">Employee</span> <span class="p">}</span> <span class="k">from</span> <span class="dl">"</span><span class="s2">../types/interface.employee.ts</span><span class="dl">"</span>
<span class="kd">const</span> <span class="nx">employees</span> <span class="o">=</span> <span class="nx">getFromServer</span><span class="o">&lt;</span><span class="nx">Employee</span><span class="o">&gt;</span><span class="p">(</span><span class="dl">"</span><span class="s2">http://www.example.com/api/employees/ahmed.json</span><span class="dl">"</span><span class="p">);</span>
</code></pre></div></div>

<p>And that barely scratches the surface of how powerful generic types can be.</p>

<h2 id="restricting-generic-types">Restricting Generic Types</h2>

<p>You can also restrict how generic your generic types can be, for example, let’s say that we have a function that logs the length of the passed value (whatever it is):</p>

<div class="language-javascript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">function</span> <span class="nf">logLength</span> <span class="p">(</span><span class="nx">val</span><span class="p">)</span> <span class="p">{</span>
    <span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nx">val</span><span class="p">.</span><span class="nx">length</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div></div>

<p>But there are only two built-in types in javascript that have the length property, <code class="language-plaintext highlighter-rouge">String</code> and <code class="language-plaintext highlighter-rouge">Array</code>. So what we can do is set a constraint on the generic type like this:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kr">interface</span> <span class="nx">hasLength</span> <span class="p">{</span>
    <span class="nl">length</span><span class="p">:</span> <span class="kr">number</span><span class="p">;</span>
<span class="p">}</span>

<span class="kd">function</span> <span class="nf">logLength</span> <span class="o">&lt;</span><span class="nx">T</span> <span class="kd">extends</span> <span class="nx">hasLength</span><span class="o">&gt;</span> <span class="p">(</span><span class="nx">val</span><span class="p">:</span> <span class="nx">T</span><span class="p">)</span> <span class="p">{</span>
    <span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nx">val</span><span class="p">.</span><span class="nx">length</span><span class="p">);</span>
<span class="p">}</span>

<span class="nf">logLength</span><span class="p">(</span><span class="dl">"</span><span class="s2">string</span><span class="dl">"</span><span class="p">);</span> <span class="c1">// OK</span>
<span class="nf">logLength</span><span class="p">([</span><span class="dl">"</span><span class="s2">a</span><span class="dl">"</span><span class="p">,</span><span class="dl">"</span><span class="s2">b</span><span class="dl">"</span><span class="p">,</span><span class="dl">"</span><span class="s2">c</span><span class="dl">"</span><span class="p">]);</span> <span class="c1">// OK</span>
<span class="nf">logLength</span><span class="p">({</span>
    <span class="na">width</span><span class="p">:</span> <span class="mi">300</span><span class="p">,</span>
    <span class="na">length</span><span class="p">:</span> <span class="mi">600</span>
<span class="p">});</span> <span class="c1">// Also OK because it has the length property</span>
<span class="nf">logLength</span><span class="p">(</span><span class="mi">17</span><span class="p">);</span> <span class="c1">// Compile Error!</span>
</code></pre></div></div>

<h2 id="index-types-with-generic-types">Index Types With Generic Types</h2>

<p>A more elaborate example is a function that copies (Using <code class="language-plaintext highlighter-rouge">JSON.stringify</code> and <code class="language-plaintext highlighter-rouge">JSON.parse</code>) a property of any object that it receives.</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">function</span> <span class="nf">copyProperty</span><span class="o">&lt;</span><span class="nx">OBJ</span><span class="p">,</span> <span class="nx">KEY</span> <span class="kd">extends</span> <span class="kr">keyof</span> <span class="nx">OBJ</span><span class="o">&gt;</span><span class="p">(</span><span class="nx">obj</span><span class="p">:</span> <span class="nx">OBJ</span><span class="p">,</span> <span class="nx">key</span><span class="p">:</span> <span class="nx">KEY</span><span class="p">):</span> <span class="nx">OBJ</span><span class="p">[</span><span class="nx">KEY</span><span class="p">]</span> <span class="p">{</span>
    <span class="kd">const</span> <span class="kr">string</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">stringify</span><span class="p">(</span><span class="nx">obj</span><span class="p">[</span><span class="nx">key</span><span class="p">]);</span>
    <span class="kd">const</span> <span class="nx">copied</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">parse</span><span class="p">(</span><span class="kr">string</span><span class="p">);</span>
    <span class="k">return</span> <span class="nx">copied</span><span class="p">;</span>
<span class="p">}</span>

<span class="kd">const</span> <span class="nx">car</span> <span class="o">=</span> <span class="p">{</span> <span class="na">engine</span><span class="p">:</span> <span class="dl">"</span><span class="s2">v8</span><span class="dl">"</span><span class="p">,</span> <span class="na">milage</span><span class="p">:</span> <span class="mi">123000</span><span class="p">,</span> <span class="na">color</span><span class="p">:</span> <span class="dl">"</span><span class="s2">red</span><span class="dl">"</span> <span class="p">};</span>
<span class="kd">const</span> <span class="nx">animal</span> <span class="o">=</span> <span class="p">{</span> <span class="na">name</span><span class="p">:</span> <span class="dl">"</span><span class="s2">Domestic Cat</span><span class="dl">"</span><span class="p">,</span> <span class="na">species</span><span class="p">:</span> <span class="dl">"</span><span class="s2">silvestris</span><span class="dl">"</span> <span class="p">};</span>

<span class="nf">copyProperty</span><span class="p">(</span><span class="nx">car</span><span class="p">,</span> <span class="dl">"</span><span class="s2">engine</span><span class="dl">"</span><span class="p">);</span> <span class="c1">// OK</span>
<span class="nf">copyProperty</span><span class="p">(</span><span class="nx">car</span><span class="p">,</span> <span class="dl">"</span><span class="s2">color</span><span class="dl">"</span><span class="p">).</span><span class="nx">length</span><span class="p">;</span> <span class="c1">// OK</span>
<span class="nf">copyProperty</span><span class="p">(</span><span class="nx">car</span><span class="p">,</span> <span class="dl">"</span><span class="s2">milage</span><span class="dl">"</span><span class="p">).</span><span class="nx">length</span><span class="p">;</span> <span class="c1">// Compile error, because it's a number!</span>
<span class="nf">copyProperty</span><span class="p">(</span><span class="nx">animal</span><span class="p">,</span> <span class="dl">"</span><span class="s2">color</span><span class="dl">"</span><span class="p">);</span> <span class="c1">// Compile error, because "color" is not a property on that object!</span>
<span class="c1">// so you can only pass the object's property names and</span>
<span class="c1">// typescript will be smart enough to determine their values</span>
</code></pre></div></div>

<p>Now let’s step it up a bit, by making our <code class="language-plaintext highlighter-rouge">copyProperty</code> able to copy multiple properties on the same call, so the second argument, will be an array of property names that will be copied and returned as an array.</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">function</span> <span class="nf">copyProperties</span><span class="o">&lt;</span><span class="nx">OBJ</span><span class="p">,</span> <span class="nx">KEY</span> <span class="kd">extends</span> <span class="kr">keyof</span> <span class="nx">OBJ</span><span class="o">&gt;</span><span class="p">(</span><span class="nx">obj</span><span class="p">:</span> <span class="nx">OBJ</span><span class="p">,</span> <span class="nx">keys</span><span class="p">:</span> <span class="nb">Array</span><span class="o">&lt;</span><span class="nx">KEY</span><span class="o">&gt;</span><span class="p">):</span> <span class="nb">Array</span><span class="o">&lt;</span><span class="nx">OBJ</span><span class="p">[</span><span class="nx">KEY</span><span class="p">]</span><span class="o">&gt;</span> <span class="p">{</span>
	<span class="k">return</span> <span class="nx">keys</span>
		<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="nx">x</span> <span class="o">=&gt;</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">stringify</span><span class="p">(</span><span class="nx">obj</span><span class="p">[</span><span class="nx">x</span><span class="p">]))</span>
		<span class="p">.</span><span class="nf">map</span><span class="p">(</span><span class="nx">x</span> <span class="o">=&gt;</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">parse</span><span class="p">(</span><span class="nx">x</span><span class="p">))</span>
<span class="p">}</span>

<span class="kd">const</span> <span class="nx">car</span> <span class="o">=</span> <span class="p">{</span> <span class="na">engine</span><span class="p">:</span> <span class="dl">"</span><span class="s2">v8</span><span class="dl">"</span><span class="p">,</span> <span class="na">milage</span><span class="p">:</span> <span class="mi">123000</span><span class="p">,</span> <span class="na">color</span><span class="p">:</span> <span class="dl">"</span><span class="s2">red</span><span class="dl">"</span> <span class="p">};</span>

<span class="kd">const</span> <span class="nx">a</span><span class="p">:</span> <span class="kr">string</span><span class="p">[]</span> <span class="o">=</span> <span class="nf">copyProperties</span><span class="p">(</span><span class="nx">car</span><span class="p">,</span> <span class="p">[</span><span class="dl">"</span><span class="s2">engine</span><span class="dl">"</span><span class="p">,</span> <span class="dl">"</span><span class="s2">color</span><span class="dl">"</span><span class="p">]);</span> <span class="c1">// OK</span>
<span class="kd">const</span> <span class="nx">b</span><span class="p">:</span> <span class="kr">string</span><span class="p">[]</span> <span class="o">=</span> <span class="nf">copyProperties</span><span class="p">(</span><span class="nx">car</span><span class="p">,</span> <span class="p">[</span><span class="dl">"</span><span class="s2">engine</span><span class="dl">"</span><span class="p">,</span> <span class="dl">"</span><span class="s2">milage</span><span class="dl">"</span><span class="p">]);</span>
<span class="c1">// ^ Compile Error! because one of the array values is a number</span>
<span class="c1">// and that's because one of the properties</span>
<span class="c1">// we're copying is "milage".</span>
</code></pre></div></div>

<h2 id="mapped-generic-types">Mapped Generic Types</h2>

<p>Sometimes, we’d like to modify the values of the object while copying it. For example, we have this document object:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">const</span> <span class="nb">document</span> <span class="o">=</span> <span class="p">{</span>
    <span class="na">title</span><span class="p">:</span> <span class="dl">"</span><span class="s2">New Document</span><span class="dl">"</span><span class="p">,</span>
    <span class="na">content</span><span class="p">:</span> <span class="dl">"</span><span class="s2">document content ...</span><span class="dl">"</span><span class="p">,</span>
    <span class="na">createdAt</span><span class="p">:</span> <span class="mi">1510680155148</span>
<span class="p">};</span>
</code></pre></div></div>

<p>We’d like the copy to hold a different value for the <code class="language-plaintext highlighter-rouge">createdAt</code> property. So we’ll write a function that copies objects and takes a second argument that will be property names and values to be edited.</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code>
<span class="c1">// this is a generic type, it takes any type (object)</span>
<span class="c1">// as an argument and returns the same type</span>
<span class="c1">// but with every property being optional</span>
<span class="kd">type</span> <span class="nb">Partial</span><span class="o">&lt;</span><span class="nx">T</span><span class="o">&gt;</span> <span class="o">=</span> <span class="p">{</span>
	<span class="p">[</span><span class="nx">P</span> <span class="k">in</span> <span class="kr">keyof</span> <span class="nx">T</span><span class="p">]?:</span> <span class="nx">T</span><span class="p">[</span><span class="nx">P</span><span class="p">]</span>
<span class="p">}</span>

<span class="kd">function</span> <span class="nf">copyAndModify</span><span class="o">&lt;</span><span class="nx">T</span><span class="o">&gt;</span><span class="p">(</span><span class="nx">obj</span><span class="p">:</span> <span class="nx">T</span><span class="p">,</span> <span class="nx">mods</span><span class="p">:</span><span class="nb">Partial</span><span class="o">&lt;</span><span class="nx">T</span><span class="o">&gt;</span><span class="p">):</span> <span class="nx">T</span> <span class="p">{</span>
	<span class="kd">const</span> <span class="kr">string</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">stringify</span><span class="p">(</span><span class="nx">obj</span><span class="p">);</span>
	<span class="kd">const</span> <span class="nx">copy</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nf">parse</span><span class="p">(</span><span class="kr">string</span><span class="p">);</span>
	<span class="nb">Object</span><span class="p">.</span><span class="nf">keys</span><span class="p">(</span><span class="nx">mods</span><span class="p">).</span><span class="nf">forEach</span><span class="p">(</span><span class="nx">key</span> <span class="o">=&gt;</span> <span class="p">{</span>
		<span class="nx">copy</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span> <span class="o">=</span> <span class="nx">mods</span><span class="p">[</span><span class="nx">key</span><span class="p">];</span>
	<span class="p">});</span>
	<span class="k">return</span> <span class="nx">copy</span><span class="p">;</span>
<span class="p">}</span>


<span class="kd">const</span> <span class="nx">doc</span> <span class="o">=</span> <span class="p">{</span>
    <span class="na">title</span><span class="p">:</span> <span class="dl">"</span><span class="s2">New Document</span><span class="dl">"</span><span class="p">,</span>
    <span class="na">content</span><span class="p">:</span> <span class="dl">"</span><span class="s2">document content ...</span><span class="dl">"</span><span class="p">,</span>
    <span class="na">createdAt</span><span class="p">:</span> <span class="mi">1510680155148</span>
<span class="p">};</span>


<span class="nf">copyAndModify</span><span class="p">(</span><span class="nx">doc</span><span class="p">,</span> <span class="p">{</span> <span class="na">createdAt</span><span class="p">:</span> <span class="k">new</span> <span class="nc">Date</span><span class="p">().</span><span class="nf">getTime</span><span class="p">()</span> <span class="p">})</span> <span class="c1">// OK</span>
<span class="nf">copyAndModify</span><span class="p">(</span><span class="nx">doc</span><span class="p">,</span> <span class="p">{</span> <span class="na">title</span><span class="p">:</span> <span class="dl">"</span><span class="s2">New title</span><span class="dl">"</span> <span class="p">})</span> <span class="c1">// OK</span>
<span class="nf">copyAndModify</span><span class="p">(</span><span class="nx">doc</span><span class="p">,</span> <span class="p">{</span> <span class="na">content</span><span class="p">:</span> <span class="mi">0</span> <span class="p">})</span>
<span class="c1">// Compile Error!</span>
<span class="c1">// Because content is a string, so we must</span>
<span class="c1">// put a string when modifying it</span>


<span class="nf">copyAndModify</span><span class="p">(</span><span class="nx">doc</span><span class="p">,</span> <span class="p">{</span> <span class="na">author</span><span class="p">:</span> <span class="dl">"</span><span class="s2">Some one</span><span class="dl">"</span> <span class="p">})</span>
<span class="c1">// Compile Error!</span>
<span class="c1">// Because we did not have the property author on the original document</span>

</code></pre></div></div>

<p>So those were some of the ways that you can utilize generic types to write a more safe and expressive code.</p>

<p>Finally, I’d like to finish this post with one of my favorite quotes:</p>

<blockquote>
  <p>Well engineered solutions fail early, fail fast, fail often.</p>
</blockquote>

<p>Happy coding!</p>]]></content><author><name>Alex Corvi</name></author><category term="TypeScript" /><summary type="html"><![CDATA[Few days ago, I wrote mongots, an alternative API for MongoDB to make it work better with TypeScript (a strongly-typed language that compiles to JS) on the NodeJS environment.]]></summary></entry><entry><title type="html">Constructors and Destructors in C</title><link href="/Constructors-and-Destructors-in-C/" rel="alternate" type="text/html" title="Constructors and Destructors in C" /><published>2017-10-25T05:00:00+00:00</published><updated>2017-10-25T05:00:00+00:00</updated><id>/Constructors%20and%20Destructors%20in%20C</id><content type="html" xml:base="/Constructors-and-Destructors-in-C/"><![CDATA[<blockquote>
  <p>Everything discussed here is a feature brought to you by the <a href="https://gcc.gnu.org/"><code class="language-plaintext highlighter-rouge">GCC</code></a> compiler. If you happen to be using a different compiler, I’m not sure all or any of this would apply given the fact that these features aren’t part of the <code class="language-plaintext highlighter-rouge">C</code> programming language per se.</p>
</blockquote>

<p>When writing programs of considerable size and complexity, we tend to modularize our code. That is, we try to think of all different components as objects that can be easily moved around and fit within existing and future code. In C, it’s common practice for developers to divide code into libraries and header files that can be included as needed. When working with someone else’s library, you’d normally rather have a getting-started document that’s as short and as concise as possible.</p>

<p>Let’s consider an example. You’re working with a team that’s responsible for implementing a stack data structure and is expected to hand you the five essential functions every stack should have: <code class="language-plaintext highlighter-rouge">push()</code>, <code class="language-plaintext highlighter-rouge">pop()</code>, <code class="language-plaintext highlighter-rouge">peek()</code>, <code class="language-plaintext highlighter-rouge">isFull()</code>, and <code class="language-plaintext highlighter-rouge">isEmpty()</code>. You’re probably already wondering “who’s going to initialize the stack? Do I have to? Will they hand me an initialized instance? Is it stack-allocated or heap-allocated? If it’s heap-allocated, do I have to worry about freeing it myself?” The stream of questions can literally be endless the more complex the library is. Wouldn’t it be better for the library to handle all the heavy lifting of having to instantiate all necessary data objects and do the housekeeping after itself when its job is finished (something of the nature of a constructor that’s called automatically once the library is included and a destructor that’s called when the library is done with)?</p>

<h2 id="constructors">Constructors</h2>

<p>Let’s assume we have a header file named ‘stack.h’:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#ifndef STACK_H
#define STACK_H
</span>
<span class="cp">#include</span> <span class="cpf">&lt;stdio.h&gt;</span><span class="c1">   // printf</span><span class="cp">
#include</span> <span class="cpf">&lt;stdlib.h&gt;</span><span class="c1">  // calloc &amp; free</span><span class="cp">
#include</span> <span class="cpf">&lt;stdbool.h&gt;</span><span class="c1"> // true &amp; false</span><span class="cp">
</span>
<span class="cp">#define STACK_CAP 12
</span>
<span class="kt">int</span><span class="o">*</span> <span class="n">stack</span><span class="p">;</span>
<span class="kt">unsigned</span> <span class="kt">int</span> <span class="n">stack_ptr</span><span class="p">;</span>

<span class="n">bool</span> <span class="nf">isEmpty</span><span class="p">()</span> <span class="p">{</span>
  <span class="k">return</span> <span class="n">stack_ptr</span> <span class="o">==</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>

<span class="n">bool</span> <span class="nf">isFull</span><span class="p">()</span> <span class="p">{</span>
  <span class="k">return</span> <span class="n">stack_ptr</span> <span class="o">==</span> <span class="n">STACK_CAP</span><span class="p">;</span>
<span class="p">}</span>

<span class="n">bool</span> <span class="nf">push</span><span class="p">(</span><span class="kt">int</span> <span class="n">val</span><span class="p">)</span> <span class="p">{</span>
  <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">isFull</span><span class="p">())</span> <span class="p">{</span>
    <span class="n">stack</span><span class="p">[</span><span class="n">stack_ptr</span><span class="o">++</span><span class="p">]</span> <span class="o">=</span> <span class="n">val</span><span class="p">;</span>
    <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
  <span class="p">}</span>
  <span class="k">return</span> <span class="nb">false</span><span class="p">;</span>
<span class="p">}</span>

<span class="n">bool</span> <span class="nf">peek</span><span class="p">(</span><span class="kt">int</span><span class="o">*</span> <span class="n">ref</span><span class="p">)</span> <span class="p">{</span>
  <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="n">isEmpty</span><span class="p">())</span> <span class="p">{</span>
    <span class="o">*</span><span class="n">ref</span> <span class="o">=</span> <span class="n">stack</span><span class="p">[</span><span class="n">stack_ptr</span> <span class="o">-</span> <span class="mi">1</span><span class="p">];</span>
    <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
  <span class="p">}</span>
  <span class="k">return</span> <span class="nb">false</span><span class="p">;</span>
<span class="p">}</span>

<span class="n">bool</span> <span class="nf">pop</span><span class="p">(</span><span class="kt">int</span><span class="o">*</span> <span class="n">ref</span><span class="p">)</span> <span class="p">{</span>
  <span class="k">if</span> <span class="p">(</span><span class="n">peek</span><span class="p">(</span><span class="n">ref</span><span class="p">))</span> <span class="p">{</span>
    <span class="n">stack_ptr</span><span class="o">--</span><span class="p">;</span>
    <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
  <span class="p">}</span>
  <span class="k">return</span> <span class="nb">false</span><span class="p">;</span>
<span class="p">}</span>

<span class="cp">#endif
</span></code></pre></div></div>

<p>You’ve probably already noticed that <code class="language-plaintext highlighter-rouge">stack</code> and <code class="language-plaintext highlighter-rouge">stack_ptr</code> are left uninitialized, so if you were to blindly use <code class="language-plaintext highlighter-rouge">push</code>, <code class="language-plaintext highlighter-rouge">peek</code>, or <code class="language-plaintext highlighter-rouge">pop</code>, you’re going to run into a segmentation fault as <code class="language-plaintext highlighter-rouge">stack</code> is a <code class="language-plaintext highlighter-rouge">NULL</code> pointer, and <code class="language-plaintext highlighter-rouge">stack_ptr</code> is likely to contain some gibberish that was left behind on the stack. The proper way to use these functions would be to allocate memory for the <code class="language-plaintext highlighter-rouge">stack</code> pointer and <code class="language-plaintext highlighter-rouge">free</code> it when you’re done. An even better way to do this would be to have this task automatically preformed at the time of including this header file. This is done through a library constructor, and it’s done as follows:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cm">/*  Library Constructor
    @Brief: This function is automatically called when
    the containing header file is included.
*/</span>
<span class="n">__attribute__</span><span class="p">((</span><span class="n">constructor</span><span class="p">))</span> <span class="kt">void</span> <span class="nf">start</span><span class="p">()</span> <span class="p">{</span>
   <span class="n">printf</span><span class="p">(</span><span class="s">"Inside Constructor</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
   <span class="n">stack_ptr</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
   <span class="n">stack</span> <span class="o">=</span> <span class="p">(</span><span class="kt">int</span><span class="o">*</span><span class="p">)</span><span class="n">calloc</span><span class="p">(</span><span class="n">STACK_CAP</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="kt">int</span><span class="p">));</span>
<span class="p">}</span>
</code></pre></div></div>

<p>The function above needs to be located inside your header file and will be automatically called once you’ve included the header file somewhere in your code.</p>

<blockquote>
  <p>In case you didn’t know, <code class="language-plaintext highlighter-rouge">#ifndef STACK_H</code>, <code class="language-plaintext highlighter-rouge">#define STACK_H</code> and <code class="language-plaintext highlighter-rouge">#endif</code> are needed to prevent multiple or recursive includes that’ll cause the compiler to run into redefinition issues.</p>
</blockquote>

<p>Now the following program:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#include</span> <span class="cpf">&lt;stdio.h&gt;</span><span class="cp">
#include</span> <span class="cpf">"header.h"</span><span class="cp">
</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="n">printf</span><span class="p">(</span><span class="s">"Inside main</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
    <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Will generate the following output:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Inside Constructor
Inside Main
</code></pre></div></div>

<p>And exit peacefully… Well not really peacefully. At least not in every sense of the word as your program has left some heap-allocated memory un-deallocated. You’re not likely going to see your program crash or anything, but you’ve still introduced a bug to your system that the OS may or may not be able to resolve depending on what OS you happen to be using. The proper way to go about programmatically solve this problem is to use a destructor in your application. A destructor is another function that gets called automatically once you’re done with the library. Read ahead to find out how this is done.</p>

<h2 id="destructors">Destructors</h2>

<p>You’re going to like this part.</p>

<p>We’ve used <code class="language-plaintext highlighter-rouge">__attribute__((constructor))</code> to introduce a constructor into our code, so you’re probably already thinking a <code class="language-plaintext highlighter-rouge">__attribute__((destructor))</code> is what we’d use to add a destructor, in which case you’d be absolutely right. Here’s our destructor function implementation for our stack library:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cm">/*  Library Destructor
    @Brief: This function is automatically called when
    the containing header file is dismissed (normally
    at the end of the program lifecycle).
*/</span>
<span class="n">__attribute__</span><span class="p">((</span><span class="n">destructor</span><span class="p">))</span> <span class="kt">void</span> <span class="nf">finish</span><span class="p">()</span> <span class="p">{</span>
   <span class="n">printf</span><span class="p">(</span><span class="s">"Inside Destructor</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
   <span class="n">free</span><span class="p">(</span><span class="n">stack</span><span class="p">);</span>
   <span class="n">stack</span> <span class="o">=</span> <span class="nb">NULL</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Now if you execute the same tiny program we’ve written above, you’ll get the following output:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Inside Constructor
Inside Main
Inside Destructor
</code></pre></div></div>

<p>And there we’ve achieved a library implementation that takes care of all necessary memory management for us.</p>]]></content><author><name>Fadi Hanna Al-Kass</name></author><category term="C" /><summary type="html"><![CDATA[Everything discussed here is a feature brought to you by the GCC compiler. If you happen to be using a different compiler, I’m not sure all or any of this would apply given the fact that these features aren’t part of the C programming language per se.]]></summary></entry><entry><title type="html">Remote Procedure Calls in C</title><link href="/Remote-Procedure-Calls-in-C/" rel="alternate" type="text/html" title="Remote Procedure Calls in C" /><published>2017-10-22T05:00:00+00:00</published><updated>2017-10-22T05:00:00+00:00</updated><id>/Remote%20Procedure%20Calls%20in%20C</id><content type="html" xml:base="/Remote-Procedure-Calls-in-C/"><![CDATA[<p>I have recently put together a quick Remote Procedure Call (RPC) demo in C and checked it into <a href="https://github.com/Alkass/cRPC">my Github account</a>, then I realized I still have a couple of minutes left on my hands, so I decided to write a walk-through blog post.</p>

<p>Remote Procedure Calls, if you’re not familiar with them, are library implementations that allow you to remotely host some code (normally in the form of classes and functions) and invoke those classes and functions as needed.</p>

<p>Why would you ever want to do that? I mean, what benefit do you get from having pieces of your code run on a remote server? There actually are a number of valid reasons why that would be the case, but I’m only interested in addressing two as I don’t want to run off topic. One reason is performance. Say a mobile app you’ve been writing requires high processing power availability to compute some complex mathematical equations. Most mobile devices aren’t meant to be cutting-edge processing devices that are able to scale up to any task you hand to them. In a case like this, you’d probably better off hand the calculation task to a more processing-ready device and ask for the results since that’s all you’re really interested in. Another reason is security. If you’re developing a banking solution, for instance, chances are you want to make it as hard as possible for reverse engineers to hack into your code and find out how deposits, withdraws, and transactions are made. RPCs are a viable option here.</p>

<p>Now onto some technical stuff…</p>

<p>If you’ve ever written TCP-based projects in your life, chances are you’ve serialized data at one end and deserialized it at the other end. Serialization often takes the form of a string that is supposedly safe to parse. If you’re a performance rat like myself, you’re probably seeing a problem already. String parsing is expensive and error prone. Having to parse a string on the fly means more code, more code (in most cases) means (1) slower code and (2) more possible bugs. More bugs means more time on debugging and less on productivity. You see where I’m going with this.</p>

<p>What I’d suggest as a better alternative is communicating through a stream of bytes that conform to a set of standards.</p>

<p>Say you’re building a remote controlled calculator with the most four basic operations (addition, subtraction, multiplication, and division). Now to be honest, I don’t know why you’d ever want to build this calculator. That’d be stupid. But for the sake of clarity, I couldn’t have thought of an easier example.</p>

<p>To properly send a request to your server, you’ll need to have an agreement on a request standard. Our request standard can be implemented as a <code class="language-plaintext highlighter-rouge">C</code> <code class="language-plaintext highlighter-rouge">struct</code> with a pre-determined number of bytes. All requests sent to the server must be fit within this number of byte count so the server will always know how many bytes to read at a time that make up a single request.</p>

<p>Before we implement our <code class="language-plaintext highlighter-rouge">Request</code> <code class="language-plaintext highlighter-rouge">struct</code>, let’s first decide what fields we need to include.</p>

<p>What we could do is always start with a conventional acknowledgment byte that helps both the server and the client decide whether the number of bytes read make up a valid request/response to be processed. This is extremely useful when debugging cases when one side of your project starts to misbehave, then you could do some debugging and make sure outgoing requests or incoming responses are valid by checking against the acknowledgment byte. We shall call this field <code class="language-plaintext highlighter-rouge">ack</code> for ease of writing.</p>

<p>Another useful field we could include is a request identifier. Identifiers are useful in cases when the client isn’t reading the responses right away and may have difficulty telling the responses apart. What we could do here is include the identifier as part of the response we send back as a server.</p>

<p>Our third field will be the operation field. This field tells us what function the user wants to execute.</p>

<p>We’ll also need two fields for the parameters.</p>

<p>Sounds about it!</p>

<p>Now, 1 field for <code class="language-plaintext highlighter-rouge">ack</code>, 1 for <code class="language-plaintext highlighter-rouge">id</code>, 1 for <code class="language-plaintext highlighter-rouge">op</code> and 2 for <code class="language-plaintext highlighter-rouge">params</code> add up to 5 bytes. Every time the server attempts to read a request, it’ll read exactly 5 bytes.</p>

<p>Our <code class="language-plaintext highlighter-rouge">strcut</code> will look like so:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">typedef</span> <span class="k">struct</span> <span class="p">{</span>
  <span class="kt">char</span> <span class="n">ack</span><span class="p">;</span>
  <span class="kt">char</span> <span class="n">id</span><span class="p">;</span>
  <span class="kt">char</span> <span class="n">op</span><span class="p">;</span>
  <span class="kt">char</span> <span class="n">params</span><span class="p">[</span><span class="mi">2</span><span class="p">];</span>
<span class="p">}</span> <span class="n">Request</span><span class="p">;</span>
</code></pre></div></div>

<p>Characters in <code class="language-plaintext highlighter-rouge">C</code> are 1 byte (8-bit) integers. because <code class="language-plaintext highlighter-rouge">byte</code> isn’t a valid data type in <code class="language-plaintext highlighter-rouge">C</code>, we can type-define it as follows:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">typedef</span> <span class="kt">char</span> <span class="n">byte</span><span class="p">;</span>
</code></pre></div></div>

<p>and use it as so:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">typedef</span> <span class="k">struct</span> <span class="p">{</span>
  <span class="n">byte</span> <span class="n">ack</span><span class="p">;</span>
  <span class="n">byte</span> <span class="n">id</span><span class="p">;</span>
  <span class="n">byte</span> <span class="n">op</span><span class="p">;</span>
  <span class="n">byte</span> <span class="n">params</span><span class="p">[</span><span class="mi">2</span><span class="p">];</span>
<span class="p">}</span> <span class="n">Request</span><span class="p">;</span>
</code></pre></div></div>

<p>Our acknowledgment byte is consensual between the server and the client. We’ll make it 10 and set it as follows:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="cp">#define ACK 0xA
</span></code></pre></div></div>

<p>Our operations can be part of an <code class="language-plaintext highlighter-rouge">OpType</code> <code class="language-plaintext highlighter-rouge">enum</code> as follows:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">typedef</span> <span class="k">enum</span> <span class="p">{</span>
  <span class="n">ADD</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span>
  <span class="n">SUB</span><span class="p">,</span>
  <span class="n">MUL</span><span class="p">,</span>
  <span class="n">DIV</span>
<span class="p">}</span> <span class="n">OpType</span><span class="p">;</span>
</code></pre></div></div>

<p>Which allows us to replace the <code class="language-plaintext highlighter-rouge">byte</code> type in our <code class="language-plaintext highlighter-rouge">Request</code> <code class="language-plaintext highlighter-rouge">struct</code> with <code class="language-plaintext highlighter-rouge">OpType</code>, except we’ll run into a problem that is <code class="language-plaintext highlighter-rouge">enums</code> in <code class="language-plaintext highlighter-rouge">C</code> are of type integer (4-bytes long), but this issue can be overcome by enabling the <code class="language-plaintext highlighter-rouge">-fshort-enums</code> <code class="language-plaintext highlighter-rouge">GCC</code> switch that reduces the size of enums to 1 byte. Now we can re-write our <code class="language-plaintext highlighter-rouge">Request</code> <code class="language-plaintext highlighter-rouge">struct</code> as follows:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">typedef</span> <span class="k">struct</span> <span class="p">{</span>
  <span class="n">byte</span> <span class="n">ack</span><span class="p">;</span>
  <span class="n">byte</span> <span class="n">id</span><span class="p">;</span>
  <span class="n">OpType</span> <span class="n">op</span><span class="p">;</span>
  <span class="n">byte</span> <span class="n">params</span><span class="p">[</span><span class="mi">2</span><span class="p">];</span>
<span class="p">}</span> <span class="n">Request</span><span class="p">;</span>
</code></pre></div></div>

<p>Now let’s define our <code class="language-plaintext highlighter-rouge">Response</code> <code class="language-plaintext highlighter-rouge">struct</code>.</p>

<p>We’ll need a starting acknowledgment byte, so that’s one.</p>

<p>We’ll also need to include the request identifier. That’s two.</p>

<p>Not every request sent to the server is a valid request. The user may be requesting a functionality that has not been yet implemented or does not exist. For this, we could include a status field that helps the client decide whether the request was handled successfully.</p>

<p>If the request is handled successfully, we’ll need to return some data to the user. We’ll need a data field to contain the result.</p>

<p>That adds up to four bytes. Here’s what our <code class="language-plaintext highlighter-rouge">Response</code> object will look like:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">typedef</span> <span class="k">struct</span> <span class="p">{</span>
  <span class="n">byte</span> <span class="n">ack</span><span class="p">;</span>
  <span class="n">byte</span> <span class="n">id</span><span class="p">;</span>
  <span class="n">byte</span> <span class="n">status</span><span class="p">;</span>
  <span class="n">byte</span> <span class="n">data</span><span class="p">;</span>
<span class="p">}</span> <span class="n">Response</span><span class="p">;</span>
</code></pre></div></div>

<p>Now assume you have a server up and running waiting to process some requests. You’d declare a <code class="language-plaintext highlighter-rouge">Request</code> object and <code class="language-plaintext highlighter-rouge">Response</code> object as follows:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">Request</span> <span class="n">req</span>  <span class="o">=</span> <span class="p">{</span><span class="mi">0</span><span class="p">};</span>
<span class="n">Response</span> <span class="n">res</span> <span class="o">=</span> <span class="p">{</span><span class="mi">0</span><span class="p">};</span>
</code></pre></div></div>

<blockquote>
  <p>The <code class="language-plaintext highlighter-rouge">{0}</code> is syntactic sugar that tells the compiler to set all values within the structure to zero.</p>
</blockquote>

<p>You’d then be reading the request as follows:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">read</span><span class="p">(</span><span class="n">comm_fd</span><span class="p">,</span> <span class="p">(</span><span class="n">byte</span><span class="o">*</span><span class="p">)</span><span class="o">&amp;</span><span class="n">req</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">Request</span><span class="p">));</span>
</code></pre></div></div>

<blockquote>
  <p>The <code class="language-plaintext highlighter-rouge">(byte*)&amp;req</code> typecasts our <code class="language-plaintext highlighter-rouge">Request</code> struct into a byte pointer.</p>
</blockquote>

<p>After a so number of bytes (5 in our case) has been read and converted to a <code class="language-plaintext highlighter-rouge">Request</code> object, we can go ahead and verify that the request is valid by checking against our consensual acknowledgment byte as follows:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">if</span> <span class="p">(</span><span class="n">req</span><span class="p">.</span><span class="n">ack</span> <span class="o">==</span> <span class="n">ACK</span><span class="p">)</span> <span class="p">{</span>
  <span class="c1">// Request is successful. Move forward</span>
<span class="p">}</span>
</code></pre></div></div>

<p>The first thing we could do is prepare the <code class="language-plaintext highlighter-rouge">ack</code> and <code class="language-plaintext highlighter-rouge">id</code> fields in our Response object as follows:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">res</span><span class="p">.</span><span class="n">ack</span> <span class="o">=</span> <span class="n">req</span><span class="p">.</span><span class="n">ack</span><span class="p">;</span>
<span class="n">res</span><span class="p">.</span><span class="n">id</span> <span class="o">=</span> <span class="n">req</span><span class="p">.</span><span class="n">id</span><span class="p">;</span>
</code></pre></div></div>

<p>Then call a <code class="language-plaintext highlighter-rouge">handleRequest</code> function that’s responsible for handling the request and handing back the data. This function (and its callees) are implemented as follows:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kt">int</span> <span class="nf">handleAdd</span><span class="p">(</span><span class="k">const</span> <span class="n">Request</span><span class="o">*</span> <span class="n">req</span><span class="p">,</span> <span class="n">Response</span><span class="o">*</span> <span class="n">res</span><span class="p">)</span> <span class="p">{</span>
  <span class="n">printf</span><span class="p">(</span><span class="s">"res-&gt;data = %d + %d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">1</span><span class="p">]);</span>
  <span class="n">res</span><span class="o">-&gt;</span><span class="n">data</span> <span class="o">=</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">+</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">1</span><span class="p">];</span>
  <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
<span class="p">}</span>

<span class="kt">int</span> <span class="nf">handleSub</span><span class="p">(</span><span class="k">const</span> <span class="n">Request</span><span class="o">*</span> <span class="n">req</span><span class="p">,</span> <span class="n">Response</span><span class="o">*</span> <span class="n">res</span><span class="p">)</span> <span class="p">{</span>
  <span class="n">printf</span><span class="p">(</span><span class="s">"res-&gt;data = %d - %d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">1</span><span class="p">]);</span>
  <span class="n">res</span><span class="o">-&gt;</span><span class="n">data</span> <span class="o">=</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">-</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">1</span><span class="p">];</span>
  <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
<span class="p">}</span>

<span class="kt">int</span> <span class="nf">handleMul</span><span class="p">(</span><span class="k">const</span> <span class="n">Request</span><span class="o">*</span> <span class="n">req</span><span class="p">,</span> <span class="n">Response</span><span class="o">*</span> <span class="n">res</span><span class="p">)</span> <span class="p">{</span>
  <span class="n">printf</span><span class="p">(</span><span class="s">"res-&gt;data = %d * %d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">1</span><span class="p">]);</span>
  <span class="n">res</span><span class="o">-&gt;</span><span class="n">data</span> <span class="o">=</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">*</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">1</span><span class="p">];</span>
  <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
<span class="p">}</span>

<span class="kt">int</span> <span class="nf">handleDiv</span><span class="p">(</span><span class="k">const</span> <span class="n">Request</span><span class="o">*</span> <span class="n">req</span><span class="p">,</span> <span class="n">Response</span><span class="o">*</span> <span class="n">res</span><span class="p">)</span> <span class="p">{</span>
  <span class="n">printf</span><span class="p">(</span><span class="s">"res-&gt;data = %d / %d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">1</span><span class="p">]);</span>
  <span class="n">res</span><span class="o">-&gt;</span><span class="n">data</span> <span class="o">=</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">/</span> <span class="n">req</span><span class="o">-&gt;</span><span class="n">params</span><span class="p">[</span><span class="mi">1</span><span class="p">];</span>
  <span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
<span class="p">}</span>

<span class="kt">int</span> <span class="nf">handleRequest</span><span class="p">(</span><span class="k">const</span> <span class="n">Request</span><span class="o">*</span> <span class="n">req</span><span class="p">,</span> <span class="n">Response</span><span class="o">*</span> <span class="n">res</span><span class="p">)</span> <span class="p">{</span>
  <span class="k">switch</span> <span class="p">(</span><span class="n">req</span><span class="o">-&gt;</span><span class="n">op</span><span class="p">)</span> <span class="p">{</span>
    <span class="k">case</span> <span class="n">ADD</span><span class="p">:</span>
      <span class="k">return</span> <span class="n">handleAdd</span><span class="p">(</span><span class="n">req</span><span class="p">,</span> <span class="n">res</span><span class="p">);</span>
    <span class="k">case</span> <span class="n">SUB</span><span class="p">:</span>
      <span class="k">return</span> <span class="n">handleSub</span><span class="p">(</span><span class="n">req</span><span class="p">,</span> <span class="n">res</span><span class="p">);</span>
    <span class="k">case</span> <span class="n">MUL</span><span class="p">:</span>
      <span class="k">return</span> <span class="n">handleMul</span><span class="p">(</span><span class="n">req</span><span class="p">,</span> <span class="n">res</span><span class="p">);</span>
    <span class="k">case</span> <span class="n">DIV</span><span class="p">:</span>
      <span class="k">return</span> <span class="n">handleDiv</span><span class="p">(</span><span class="n">req</span><span class="p">,</span> <span class="n">res</span><span class="p">);</span>
    <span class="nl">default:</span>
      <span class="k">return</span> <span class="nb">false</span><span class="p">;</span>
  <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<p>And can be called as follows:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">if</span> <span class="p">(</span><span class="n">handleRequest</span><span class="p">(</span><span class="o">&amp;</span><span class="n">req</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">res</span><span class="p">))</span> <span class="p">{</span>
  <span class="n">res</span><span class="p">.</span><span class="n">status</span> <span class="o">=</span> <span class="nb">true</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">else</span> <span class="p">{</span>
  <span class="n">res</span><span class="p">.</span><span class="n">status</span> <span class="o">=</span> <span class="nb">false</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p>The response can be sent to the client as follows:</p>

<div class="language-c highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">write</span><span class="p">(</span><span class="n">comm_fd</span><span class="p">,</span> <span class="p">(</span><span class="n">byte</span><span class="o">*</span><span class="p">)</span><span class="o">&amp;</span><span class="n">res</span><span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="n">Response</span><span class="p">));</span>
</code></pre></div></div>

<p>And there we have a fully functional RPC server implementation capable of performing just about anything when expanded.</p>

<blockquote>
  <p>The demo I referred to at the beginning of this post can be found <a href="https://github.com/Alkass/cRPC">here</a></p>
</blockquote>]]></content><author><name>Fadi Hanna Al-Kass</name></author><category term="C" /><summary type="html"><![CDATA[I have recently put together a quick Remote Procedure Call (RPC) demo in C and checked it into my Github account, then I realized I still have a couple of minutes left on my hands, so I decided to write a walk-through blog post.]]></summary></entry><entry><title type="html">Crafting Code - Building Common Interfaces</title><link href="/Crafting-Code-1/" rel="alternate" type="text/html" title="Crafting Code - Building Common Interfaces" /><published>2017-06-20T05:00:00+00:00</published><updated>2017-06-20T05:00:00+00:00</updated><id>/Crafting%20Code%201</id><content type="html" xml:base="/Crafting-Code-1/"><![CDATA[<p>When writing libraries, APIs, and SDKs, the less stuff you ask your user to memorize the better it looks to you and feels to them. For instance, if you were to write a Math library that performs some arithmetic operations, you could write your library functions as so:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">add</span><span class="p">(</span><span class="n">op1</span><span class="p">:</span> <span class="nb">f32</span><span class="p">,</span> <span class="n">op2</span><span class="p">:</span> <span class="nb">f32</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">f32</span> <span class="p">{</span>
  <span class="n">op1</span> <span class="o">+</span> <span class="n">op2</span>
<span class="p">}</span>

<span class="k">fn</span> <span class="nf">sub</span><span class="p">(</span><span class="n">op1</span><span class="p">:</span> <span class="nb">f32</span><span class="p">,</span> <span class="n">op2</span><span class="p">:</span> <span class="nb">f32</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">f32</span> <span class="p">{</span>
  <span class="n">op1</span> <span class="o">-</span> <span class="n">op2</span>
<span class="p">}</span>

<span class="k">fn</span> <span class="nf">mul</span><span class="p">(</span><span class="n">op1</span><span class="p">:</span> <span class="nb">f32</span><span class="p">,</span> <span class="n">op2</span><span class="p">:</span> <span class="nb">f32</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">f32</span> <span class="p">{</span>
  <span class="n">op1</span> <span class="o">*</span> <span class="n">op2</span>
<span class="p">}</span>

<span class="k">fn</span> <span class="nf">div</span><span class="p">(</span><span class="n">op1</span><span class="p">:</span> <span class="nb">f32</span><span class="p">,</span> <span class="n">op2</span><span class="p">:</span> <span class="nb">f32</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">f32</span> <span class="p">{</span>
  <span class="n">op1</span> <span class="o">/</span> <span class="n">op2</span>
<span class="p">}</span>
</code></pre></div></div>

<p>And that’ll require the user to import his/her desired function or set of functions as needed. This is fine, but wouldn’t it be better if you could provide only one function that does all these operations? We’re going to call this function a common interface, but this procedure is called a passthrough in the professional field. A passthrough function is a multi-purpose entry point to a set of different classes or functions. In the case of our Math library, we could have our passthrough function written as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">passthrough</span><span class="p">(</span><span class="n">operation</span><span class="p">:</span> <span class="o">&amp;</span><span class="k">'static</span> <span class="nb">str</span><span class="p">,</span> <span class="n">op1</span><span class="p">:</span> <span class="nb">f32</span><span class="p">,</span> <span class="n">op2</span><span class="p">:</span> <span class="nb">f32</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">f32</span> <span class="p">{</span>
  <span class="k">return</span> <span class="k">match</span> <span class="n">operation</span> <span class="p">{</span>
    <span class="s">"+"</span> <span class="k">=&gt;</span> <span class="nf">add</span><span class="p">(</span><span class="n">op1</span><span class="p">,</span> <span class="n">op2</span><span class="p">),</span>
    <span class="s">"-"</span> <span class="k">=&gt;</span> <span class="nf">sub</span><span class="p">(</span><span class="n">op1</span><span class="p">,</span> <span class="n">op2</span><span class="p">),</span>
    <span class="s">"*"</span> <span class="k">=&gt;</span> <span class="nf">mul</span><span class="p">(</span><span class="n">op1</span><span class="p">,</span> <span class="n">op2</span><span class="p">),</span>
    <span class="s">"/"</span> <span class="k">=&gt;</span> <span class="nf">div</span><span class="p">(</span><span class="n">op1</span><span class="p">,</span> <span class="n">op2</span><span class="p">),</span>
    <span class="n">_</span> <span class="k">=&gt;</span> <span class="mi">0</span> <span class="k">as</span> <span class="nb">f32</span><span class="p">,</span> <span class="c1">//Return 0 if unknown operation. Near future bug alert!!!</span>
  <span class="p">};</span>
<span class="p">}</span>
</code></pre></div></div>

<p>That allows us to do something like this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">res</span> <span class="o">=</span> <span class="nf">passthrough</span><span class="p">(</span><span class="s">"+"</span><span class="p">,</span> <span class="mi">10</span> <span class="k">as</span> <span class="nb">f32</span><span class="p">,</span> <span class="mf">12.3</span><span class="p">);</span>
</code></pre></div></div>

<p>Instead of this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">res</span> <span class="o">=</span> <span class="nf">add</span><span class="p">(</span><span class="mf">32.4</span><span class="p">,</span> <span class="mi">12</span> <span class="k">as</span> <span class="nb">f32</span><span class="p">);</span>
</code></pre></div></div>

<p>But there’s more we could do here. So, for instance, instead of specifying the operation as a string and expose our code to all sorts of correctness bugs (afterall, our <code class="language-plaintext highlighter-rouge">passthrough()</code> function won’t warn us about an invalid operation), we could do something like this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">enum</span> <span class="n">OperationType</span> <span class="p">{</span>
    <span class="n">ADD</span><span class="p">,</span>
    <span class="n">SUB</span><span class="p">,</span>
    <span class="n">MUL</span><span class="p">,</span>
    <span class="n">DIV</span><span class="p">,</span>
<span class="p">}</span>

<span class="k">fn</span> <span class="nf">passthrough</span><span class="p">(</span><span class="n">operation</span><span class="p">:</span> <span class="n">OperationType</span><span class="p">,</span> <span class="n">op1</span><span class="p">:</span> <span class="nb">f32</span><span class="p">,</span> <span class="n">op2</span><span class="p">:</span> <span class="nb">f32</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">f32</span> <span class="p">{</span>
  <span class="k">return</span> <span class="k">match</span> <span class="n">operation</span> <span class="p">{</span>
    <span class="nn">OperationType</span><span class="p">::</span><span class="n">ADD</span> <span class="k">=&gt;</span> <span class="nf">add</span><span class="p">(</span><span class="n">op1</span><span class="p">,</span> <span class="n">op2</span><span class="p">),</span>
    <span class="nn">OperationType</span><span class="p">::</span><span class="n">SUB</span> <span class="k">=&gt;</span> <span class="nf">sub</span><span class="p">(</span><span class="n">op1</span><span class="p">,</span> <span class="n">op2</span><span class="p">),</span>
    <span class="nn">OperationType</span><span class="p">::</span><span class="n">MUL</span> <span class="k">=&gt;</span> <span class="nf">mul</span><span class="p">(</span><span class="n">op1</span><span class="p">,</span> <span class="n">op2</span><span class="p">),</span>
    <span class="nn">OperationType</span><span class="p">::</span><span class="n">DIV</span> <span class="k">=&gt;</span> <span class="nf">div</span><span class="p">(</span><span class="n">op1</span><span class="p">,</span> <span class="n">op2</span><span class="p">),</span>
  <span class="p">};</span>
<span class="p">}</span>
</code></pre></div></div>

<p>That will at least force the user to select one of many options, and anything that’s not on the list won’t slide. But that’s not all either. There’s still more that can be done to tweak our code.</p>

<p>Notice how <code class="language-plaintext highlighter-rouge">passthrough</code> will always take two operands, no more or less parameters. What if, in the future, you decide to add an operation that requires only one operand (a square root function for example). You may be able to get away with something as easy as <code class="language-plaintext highlighter-rouge">passthrough(OperationType::SQRT, 25, 0)</code>, but that neither looks clean nor is something a team of professional developers would approve of. Perhaps we could turn our operands into a flexible object, and for the sake of simplicity we shall call our object <code class="language-plaintext highlighter-rouge">Request</code> and have it implemented as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">enum</span> <span class="n">Request</span> <span class="p">{</span>
    <span class="n">NoOps</span><span class="p">,</span>
    <span class="nf">OneOp</span><span class="p">(</span><span class="nb">f32</span><span class="p">),</span>
    <span class="nf">TwoOps</span><span class="p">(</span><span class="nb">f32</span><span class="p">,</span> <span class="nb">f32</span><span class="p">),</span>
    <span class="nf">ThreeOps</span><span class="p">(</span><span class="nb">f32</span><span class="p">,</span> <span class="nb">f32</span><span class="p">,</span> <span class="nb">f32</span><span class="p">),</span>
<span class="p">}</span>
</code></pre></div></div>

<p>And re-implement our <code class="language-plaintext highlighter-rouge">passthrough()</code> function to work with a <code class="language-plaintext highlighter-rouge">Request</code> object as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">passthrough</span><span class="p">(</span><span class="n">operation</span><span class="p">:</span> <span class="n">OperationType</span><span class="p">,</span> <span class="n">req</span><span class="p">:</span> <span class="n">Request</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">f32</span> <span class="p">{</span>
  <span class="k">return</span> <span class="k">match</span> <span class="n">operation</span> <span class="p">{</span>
    <span class="nn">OperationType</span><span class="p">::</span><span class="n">ADD</span> <span class="k">=&gt;</span> <span class="nf">add</span><span class="p">(</span><span class="n">req</span><span class="p">),</span>
    <span class="nn">OperationType</span><span class="p">::</span><span class="n">SUB</span> <span class="k">=&gt;</span> <span class="nf">sub</span><span class="p">(</span><span class="n">req</span><span class="p">),</span>
    <span class="nn">OperationType</span><span class="p">::</span><span class="n">MUL</span> <span class="k">=&gt;</span> <span class="nf">mul</span><span class="p">(</span><span class="n">req</span><span class="p">),</span>
    <span class="nn">OperationType</span><span class="p">::</span><span class="n">DIV</span> <span class="k">=&gt;</span> <span class="nf">div</span><span class="p">(</span><span class="n">req</span><span class="p">),</span>
  <span class="p">};</span>
<span class="p">}</span>
</code></pre></div></div>

<p>And re-implement our arithmetic functions to use our <code class="language-plaintext highlighter-rouge">Request</code> object instead of straight operands:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">add</span><span class="p">(</span><span class="n">req</span><span class="p">:</span> <span class="n">Request</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">f32</span> <span class="p">{</span>
  <span class="k">return</span> <span class="k">match</span> <span class="n">req</span> <span class="p">{</span>
    <span class="nn">Request</span><span class="p">::</span><span class="n">NoOps</span> <span class="k">=&gt;</span> <span class="mi">0</span> <span class="k">as</span> <span class="nb">f32</span><span class="p">,</span>
    <span class="nn">Request</span><span class="p">::</span><span class="nf">OneOp</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="n">a</span><span class="p">,</span><span class="n">w</span>
    <span class="nn">Request</span><span class="p">::</span><span class="nf">TwoOps</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span><span class="p">,</span>
    <span class="nn">Request</span><span class="p">::</span><span class="nf">ThreeOps</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span> <span class="o">+</span> <span class="n">c</span><span class="p">,</span>
  <span class="p">};</span>
<span class="p">}</span>
</code></pre></div></div>

<p>And the resulting code will then allow us to do something like this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">res</span> <span class="o">=</span> <span class="nf">passthrough</span><span class="p">(</span><span class="nn">OperationType</span><span class="p">::</span><span class="n">ADD</span><span class="p">,</span> <span class="nn">Request</span><span class="p">::</span><span class="n">NoOps</span><span class="p">);</span>
</code></pre></div></div>

<p>Or this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">res</span> <span class="o">=</span> <span class="nf">passthrough</span><span class="p">(</span><span class="nn">OperationType</span><span class="p">::</span><span class="n">ADD</span><span class="p">,</span> <span class="nn">Request</span><span class="p">::</span><span class="nf">TwoOps</span><span class="p">(</span><span class="mf">10.1</span><span class="p">,</span> <span class="mf">40.5</span><span class="p">));</span>
</code></pre></div></div>

<p>Or this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">res</span> <span class="o">=</span> <span class="nf">passthrough</span><span class="p">(</span><span class="nn">OperationType</span><span class="p">::</span><span class="n">ADD</span><span class="p">,</span> <span class="nn">Request</span><span class="p">::</span><span class="nf">ThreeOps</span><span class="p">(</span><span class="mf">10.1</span><span class="p">,</span> <span class="mf">40.5</span><span class="p">));</span>
</code></pre></div></div>

<p>There’s still more room for improvement, but you get the point.</p>

<p>So, “why should I consider a passthrough design?”, you may wonder! Here are some reasons why:</p>

<ul>
  <li>
    <p>Passthroughs allow you to completely maintain your own code when working with a team of developers. That is to say your code needs not be scattered around, nor will anyone need direct access to any of your functions; you make your inner functions private, provide a <code class="language-plaintext highlighter-rouge">passthrough</code> function and there you roll ^_^.</p>
  </li>
  <li>
    <p>Documentation becomes a breeze. Think about it. Instead of having to document every single function and provide snippets and use cases, you can keep all these functions private and only worry about documenting one: your <code class="language-plaintext highlighter-rouge">passthrough()</code> function. This can save you lots and lots of time.</p>
  </li>
</ul>]]></content><author><name>Fadi Hanna Al-Kass</name></author><category term="Rust" /><summary type="html"><![CDATA[When writing libraries, APIs, and SDKs, the less stuff you ask your user to memorize the better it looks to you and feels to them. For instance, if you were to write a Math library that performs some arithmetic operations, you could write your library functions as so:]]></summary></entry><entry><title type="html">Enum and Match Systems in Rust</title><link href="/Enum-and-Match-Systems-in-Rust/" rel="alternate" type="text/html" title="Enum and Match Systems in Rust" /><published>2017-06-17T05:00:00+00:00</published><updated>2017-06-17T05:00:00+00:00</updated><id>/Enum%20and%20Match%20Systems%20in%20Rust</id><content type="html" xml:base="/Enum-and-Match-Systems-in-Rust/"><![CDATA[<p>You’ve probably worked with <code class="language-plaintext highlighter-rouge">enums</code> before, but if you haven’t, they’re basically a way to have a selection out of a number of different options. A <code class="language-plaintext highlighter-rouge">Person</code> struct could contain a <code class="language-plaintext highlighter-rouge">gender</code> field that points to an enum of three options (<code class="language-plaintext highlighter-rouge">Male</code>, <code class="language-plaintext highlighter-rouge">Female</code>, and <code class="language-plaintext highlighter-rouge">Undisclosed</code>), i.e.:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="k">enum</span> <span class="n">PersonGender</span> <span class="p">{</span>
    <span class="n">MALE</span><span class="p">,</span>
    <span class="n">FEMALE</span><span class="p">,</span>
    <span class="n">UNDISCLOSED</span><span class="p">,</span>
  <span class="p">}</span>

  <span class="k">struct</span> <span class="n">Person</span> <span class="p">{</span>
    <span class="n">name</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span>
    <span class="n">age</span><span class="p">:</span> <span class="nb">i8</span><span class="p">,</span>
    <span class="n">gender</span><span class="p">:</span> <span class="n">PersonGender</span><span class="p">,</span>
  <span class="p">}</span>

  <span class="k">fn</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="k">let</span> <span class="n">person</span> <span class="o">=</span> <span class="n">Person</span> <span class="p">{</span>
      <span class="n">name</span><span class="p">:</span> <span class="s">"Fadi Hanna Al-Kass"</span><span class="nf">.to_string</span><span class="p">(),</span>
      <span class="n">age</span><span class="p">:</span> <span class="mi">27</span><span class="p">,</span>
      <span class="n">gender</span><span class="p">:</span> <span class="nn">PersonGender</span><span class="p">::</span><span class="n">MALE</span><span class="p">,</span>
    <span class="p">};</span>
  <span class="p">}</span>
</code></pre></div></div>

<p>Now, what if a person so chooses to identify as something else? In that case, you could add a 4th option (<code class="language-plaintext highlighter-rouge">Other</code>) and attach a value of type <code class="language-plaintext highlighter-rouge">String</code> to it. Here’s what your end result would look like:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="k">enum</span> <span class="n">PersonGender</span> <span class="p">{</span>
    <span class="n">MALE</span><span class="p">,</span>
    <span class="n">FEMALE</span><span class="p">,</span>
    <span class="n">UNDISCLOSED</span><span class="p">,</span>
    <span class="nf">OTHER</span><span class="p">(</span><span class="nb">String</span><span class="p">),</span>
  <span class="p">}</span>

  <span class="k">struct</span> <span class="n">Person</span> <span class="p">{</span>
    <span class="n">name</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span>
    <span class="n">age</span><span class="p">:</span> <span class="nb">i8</span><span class="p">,</span>
    <span class="n">gender</span><span class="p">:</span> <span class="n">PersonGender</span><span class="p">,</span>
  <span class="p">}</span>

  <span class="k">fn</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="k">let</span> <span class="n">person</span> <span class="o">=</span> <span class="n">Person</span> <span class="p">{</span>
      <span class="n">name</span><span class="p">:</span> <span class="s">"Jake Smith"</span><span class="nf">.to_string</span><span class="p">(),</span>
      <span class="n">age</span><span class="p">:</span> <span class="mi">27</span><span class="p">,</span>
      <span class="n">gender</span><span class="p">:</span> <span class="nn">PersonGender</span><span class="p">::</span><span class="nf">OTHER</span><span class="p">(</span><span class="s">"Agender"</span><span class="nf">.to_string</span><span class="p">()),</span>
    <span class="p">};</span>
  <span class="p">}</span>
</code></pre></div></div>

<p>Of course <code class="language-plaintext highlighter-rouge">enums</code> don’t have to be part of a struct, and <code class="language-plaintext highlighter-rouge">enum</code> values don’t have to be primitives either. An <code class="language-plaintext highlighter-rouge">enum</code> value can point to a <code class="language-plaintext highlighter-rouge">struct</code> or even another <code class="language-plaintext highlighter-rouge">enum</code> and so on. For instance, you can write a function that returns a status that’s either <code class="language-plaintext highlighter-rouge">PASS</code> or <code class="language-plaintext highlighter-rouge">FAILURE</code>. <code class="language-plaintext highlighter-rouge">PASS</code> can include a string while <code class="language-plaintext highlighter-rouge">FAILURE</code> can contain more information about the severity of the failure. This functionality can be achieved as so:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="k">enum</span> <span class="n">SeverityStatus</span> <span class="p">{</span>
    <span class="nf">BENIGN</span><span class="p">(</span><span class="nb">String</span><span class="p">),</span>
    <span class="nf">FATAL</span><span class="p">(</span><span class="nb">String</span><span class="p">),</span>
  <span class="p">}</span>

  <span class="k">enum</span> <span class="n">FunctionStatus</span> <span class="p">{</span>
    <span class="nf">PASS</span><span class="p">(</span><span class="nb">String</span><span class="p">),</span>
    <span class="nf">FAILURE</span><span class="p">(</span><span class="n">SeverityStatus</span><span class="p">),</span>
  <span class="p">}</span>

  <span class="k">fn</span> <span class="nf">compute_results</span><span class="p">()</span> <span class="k">-&gt;</span> <span class="n">FunctionStatus</span> <span class="p">{</span>
    <span class="c1">// Successful execution would look like the following:</span>
    <span class="c1">// return FunctionStatus::PASS("Everything looks good".to_string());</span>

    <span class="c1">// While a failure would be indicated as follows:</span>
    <span class="k">return</span> <span class="nn">FunctionStatus</span><span class="p">::</span><span class="nf">FAILURE</span><span class="p">(</span><span class="nn">SeverityStatus</span><span class="p">::</span><span class="nf">FATAL</span><span class="p">(</span><span class="s">"Continuing beyond this point will cause more damage to the hardware"</span><span class="nf">.to_string</span><span class="p">()));</span>
  <span class="p">}</span>
</code></pre></div></div>

<p>Now onto <code class="language-plaintext highlighter-rouge">match</code>. One of the things I love the most about <code class="language-plaintext highlighter-rouge">match</code> is its ability to unstructure objects. Let’s take a second look at our last code snippet and see how we can possibly handle the response coming back to us from <code class="language-plaintext highlighter-rouge">compute_results()</code>. For this, I’d definitely use a set of <code class="language-plaintext highlighter-rouge">match</code> statements, e.g.:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="k">fn</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="k">let</span> <span class="n">res</span> <span class="o">=</span> <span class="nf">compute_results</span><span class="p">();</span>
    <span class="k">match</span> <span class="n">res</span> <span class="p">{</span>
      <span class="nn">FunctionStatus</span><span class="p">::</span><span class="nf">PASS</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="p">{</span>
        <span class="c1">// Handling a PASS response</span>
        <span class="nd">println!</span><span class="p">(</span><span class="s">"PASS: {}"</span><span class="p">,</span> <span class="n">x</span><span class="p">);</span>
      <span class="p">}</span>
      <span class="nn">FunctionStatus</span><span class="p">::</span><span class="nf">FAILURE</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="p">{</span>
        <span class="c1">// Handling a FAILURE response</span>
        <span class="k">match</span> <span class="n">x</span> <span class="p">{</span>
          <span class="nn">SeverityStatus</span><span class="p">::</span><span class="nf">BENIGN</span><span class="p">(</span><span class="n">y</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="p">{</span>
            <span class="c1">// Handling a BENIGN FAILURE response</span>
            <span class="nd">println!</span><span class="p">(</span><span class="s">"BENIGN: {}"</span><span class="p">,</span> <span class="n">y</span><span class="p">);</span>
          <span class="p">}</span>
          <span class="nn">SeverityStatus</span><span class="p">::</span><span class="nf">FATAL</span><span class="p">(</span><span class="n">y</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="p">{</span>
            <span class="c1">// Handling a FATAL FAILURE response</span>
            <span class="nd">println!</span><span class="p">(</span><span class="s">"FATAL: {}"</span><span class="p">,</span> <span class="n">y</span><span class="p">);</span>
          <span class="p">}</span>
        <span class="p">};</span>
      <span class="p">}</span>
    <span class="p">};</span>
  <span class="p">}</span>
</code></pre></div></div>

<p>Now, if you happen to add more options to any of the two <code class="language-plaintext highlighter-rouge">enums</code> (say, a <code class="language-plaintext highlighter-rouge">WARN</code> option to <code class="language-plaintext highlighter-rouge">FunctionStatus</code> or <code class="language-plaintext highlighter-rouge">UNCATEGORIZED</code> to <code class="language-plaintext highlighter-rouge">SeverityStatus</code>), the compiler will refuse to compile your code until all possible cases are handled. This is definitely a plus as it forces you to think about all the paths your code could take.</p>

<p>However, there will be times when you really only want to handle specific cases and not the rest. For instance, we may only be interested in handling the case of failure of <code class="language-plaintext highlighter-rouge">compute_results()</code> and ignore all passes. For that you could use the <code class="language-plaintext highlighter-rouge">_</code> case. <code class="language-plaintext highlighter-rouge">_</code> in the case of a <code class="language-plaintext highlighter-rouge">match</code> statement or expression means “everything else”. So, to write our <code class="language-plaintext highlighter-rouge">FunctionStatus</code> handling functionality in a way when only failures are handled, we could do the following:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="k">fn</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="k">let</span> <span class="n">res</span> <span class="o">=</span> <span class="nf">compute_results</span><span class="p">();</span>
    <span class="k">match</span> <span class="n">res</span> <span class="p">{</span>
      <span class="nn">FunctionStatus</span><span class="p">::</span><span class="nf">FAILURE</span><span class="p">(</span><span class="n">severity</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="p">{</span>
        <span class="k">match</span> <span class="n">severity</span> <span class="p">{</span>
          <span class="nn">SeverityStatus</span><span class="p">::</span><span class="nf">FATAL</span><span class="p">(</span><span class="n">message</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="p">{</span>
            <span class="nd">println!</span><span class="p">(</span><span class="s">"FATAL: {}"</span><span class="p">,</span> <span class="n">message</span><span class="p">);</span>
          <span class="p">}</span>
          <span class="nn">SeverityStatus</span><span class="p">::</span><span class="nf">BENIGN</span><span class="p">(</span><span class="n">message</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="p">{</span>
            <span class="nd">println!</span><span class="p">(</span><span class="s">"BENIGN: {}"</span><span class="p">,</span> <span class="n">message</span><span class="p">);</span>
          <span class="p">}</span>
        <span class="p">};</span>
      <span class="p">}</span>
      <span class="n">_</span> <span class="k">=&gt;</span> <span class="p">{</span>
        <span class="c1">// Here goes the handling of "everything else", or it can be left out completely</span>
      <span class="p">}</span>
    <span class="p">};</span>
  <span class="p">}</span>
</code></pre></div></div>

<p>The same thing can be applied to <code class="language-plaintext highlighter-rouge">SeverityStatus</code>. If you want to ignore benign failures, you can replace that specific case with <code class="language-plaintext highlighter-rouge">_</code>.</p>

<p>The only drawback to using <code class="language-plaintext highlighter-rouge">_</code> is that “everything else” will include any options you include in future instances, so I’d personally strongly advocate against the use of <code class="language-plaintext highlighter-rouge">_</code>. If you want to leave some cases unhandled, you could still include them and let them point to an empty block of code, e.g.:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="k">fn</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="k">let</span> <span class="n">res</span> <span class="o">=</span> <span class="nf">compute_results</span><span class="p">();</span>
    <span class="k">match</span> <span class="n">res</span> <span class="p">{</span>
      <span class="nn">FunctionStatus</span><span class="p">::</span><span class="nf">FAILURE</span><span class="p">(</span><span class="n">severity</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="p">{</span>
        <span class="k">match</span> <span class="n">severity</span> <span class="p">{</span>
          <span class="nn">SeverityStatus</span><span class="p">::</span><span class="nf">FATAL</span><span class="p">(</span><span class="n">message</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="p">{</span>
            <span class="nd">println!</span><span class="p">(</span><span class="s">"FATAL: {}"</span><span class="p">,</span> <span class="n">message</span><span class="p">);</span>
          <span class="p">}</span>
          <span class="nn">SeverityStatus</span><span class="p">::</span><span class="nf">BENIGN</span><span class="p">(</span><span class="n">_</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="p">{</span>
            <span class="c1">// Leaving this case unhandled</span>
            <span class="c1">// NOTE: you can't print _. If you change your mind and decide to</span>
            <span class="c1">// actually handle this case, replace `_` with a valid variable name.</span>
          <span class="p">}</span>
        <span class="p">};</span>
      <span class="p">}</span>
      <span class="nn">FunctionStatus</span><span class="p">::</span><span class="nf">PASS</span><span class="p">(</span><span class="n">_</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="p">{</span>
        <span class="c1">// Leaving this case unhandled</span>
      <span class="p">}</span>
    <span class="p">};</span>
  <span class="p">}</span>
</code></pre></div></div>

<p>One last thing I wanted to touch on before I wrap up with this post. When using <code class="language-plaintext highlighter-rouge">match</code> to unstructure objects, you’ll come across projects with multiple fields, or even worse, nested object structures. Our <code class="language-plaintext highlighter-rouge">Person</code> structure can be used as an example here. How would we match this object? following’s how.</p>

<p>Say you’re interested in only unstructuring the gender and the age of a person object. You’d do this as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code>  <span class="k">fn</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
    <span class="k">let</span> <span class="n">person</span> <span class="o">=</span> <span class="n">Person</span> <span class="p">{</span>
      <span class="n">name</span><span class="p">:</span> <span class="s">"Fadi Hanna Al-Kass"</span><span class="nf">.to_string</span><span class="p">(),</span>
      <span class="n">age</span><span class="p">:</span> <span class="mi">27</span><span class="p">,</span>
      <span class="n">gender</span><span class="p">:</span> <span class="nn">PersonGender</span><span class="p">::</span><span class="n">MALE</span><span class="p">,</span>
    <span class="p">};</span>

    <span class="k">match</span> <span class="n">person</span> <span class="p">{</span>
      <span class="n">Person</span> <span class="p">{</span> <span class="n">age</span><span class="p">,</span> <span class="n">gender</span><span class="p">,</span> <span class="o">..</span> <span class="p">}</span> <span class="k">=&gt;</span> <span class="p">{</span>
        <span class="nd">println!</span><span class="p">(</span><span class="s">"age: {}"</span><span class="p">,</span> <span class="n">age</span><span class="p">);</span>
        <span class="k">match</span> <span class="n">gender</span> <span class="p">{</span>
          <span class="nn">PersonGender</span><span class="p">::</span><span class="n">MALE</span> <span class="k">=&gt;</span> <span class="p">{</span>
            <span class="nd">println!</span><span class="p">(</span><span class="s">"gender is male"</span><span class="p">);</span>
          <span class="p">}</span>
          <span class="nn">PersonGender</span><span class="p">::</span><span class="n">FEMALE</span> <span class="k">=&gt;</span> <span class="p">{</span>
            <span class="nd">println!</span><span class="p">(</span><span class="s">"gender is female"</span><span class="p">);</span>
          <span class="p">}</span>
          <span class="nn">PersonGender</span><span class="p">::</span><span class="n">UNDISCLOSED</span> <span class="k">=&gt;</span> <span class="p">{</span>
            <span class="nd">println!</span><span class="p">(</span><span class="s">"gender Undisclosed"</span><span class="p">);</span>
          <span class="p">}</span>
          <span class="nn">PersonGender</span><span class="p">::</span><span class="nf">OTHER</span><span class="p">(</span><span class="n">g</span><span class="p">)</span> <span class="k">=&gt;</span> <span class="p">{</span>
            <span class="nd">println!</span><span class="p">(</span><span class="s">"gender: {}"</span><span class="p">,</span> <span class="n">g</span><span class="p">);</span>
          <span class="p">}</span>
        <span class="p">};</span>
      <span class="p">}</span>
    <span class="p">}</span>
  <span class="p">}</span>
</code></pre></div></div>

<p>That’s all I have for now. Don’t hesitate to hit me up if you have questions.</p>]]></content><author><name>Fadi Hanna Al-Kass</name></author><category term="Rust" /><summary type="html"><![CDATA[You’ve probably worked with enums before, but if you haven’t, they’re basically a way to have a selection out of a number of different options. A Person struct could contain a gender field that points to an enum of three options (Male, Female, and Undisclosed), i.e.:]]></summary></entry><entry><title type="html">My Thoughts on TypeScript</title><link href="/My-Thoughts-on-TypeScript/" rel="alternate" type="text/html" title="My Thoughts on TypeScript" /><published>2017-04-14T05:00:00+00:00</published><updated>2017-04-14T05:00:00+00:00</updated><id>/My%20Thoughts%20on%20TypeScript</id><content type="html" xml:base="/My-Thoughts-on-TypeScript/"><![CDATA[<p>I was introduced to TypeScript when it first came with angular 2. However, I tried to avoid it as much as possible. This was actually the main reason of why I left angular in favor of Vue. “A new quirky front-end language is the last thing I would need,” I thought.</p>

<p>That was true until I was deep into my <a href="https://github.com/finnlp/">NLP</a> project in late 2016. The code base was relatively large, so many modules and functions. A friend of mine, recommended TypeScript, and I tried it. I’ve been working with it for the last 4 months, and here are my thoughts.</p>

<h2 id="type-checking-is-more-important-than-what-you-think">Type checking is more important than what you think</h2>

<p>You might ask: why would anyone spend their time and energy writing:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">function</span> <span class="nf">add</span> <span class="p">(</span><span class="nx">a</span><span class="p">:</span> <span class="kr">number</span><span class="p">,</span> <span class="nx">b</span><span class="p">:</span> <span class="kr">number</span><span class="p">):</span> <span class="kr">number</span> <span class="p">{</span>
	<span class="k">return</span> <span class="nx">a</span> <span class="o">+</span> <span class="nx">b</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Instead of:</p>

<div class="language-javascript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">function</span> <span class="nf">add</span> <span class="p">(</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">return</span> <span class="nx">a</span> <span class="o">+</span> <span class="nx">b</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p>The TL:DR; answer is:</p>

<ul>
  <li>Reduced bugs.</li>
  <li>Compile time errors instead of runtime errors.</li>
  <li>Better tooling.</li>
  <li>Code completion.</li>
</ul>

<p>As for time and energy, developers usually spend more time reading code than writing it. TypeScript is clean and well-designed (a Microsoft product by Anders Hejlsberg the author of C#, Turbo Pascal and Delphi). So while you’re going to spend a little bit extra time writing code, but with better tooling you’ll be reading less. Especially when working in a team.</p>

<p>As you import the module, you’ll have inline documentation, code completion and you can jump to definition. Those are limited, or sometimes, not even possible with a dynamic language such as JavaScript.</p>

<h3 id="reduced-bugs-and-compile-time-errors">Reduced bugs and compile time errors</h3>

<p>Take the previous example for instance:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">let</span> <span class="nx">a</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
<span class="kd">let</span> <span class="nx">b</span> <span class="o">=</span> <span class="dl">"</span><span class="s2">string</span><span class="dl">"</span><span class="p">;</span>
<span class="nf">add</span><span class="p">(</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">);</span>
</code></pre></div></div>

<p>In javascript, the aforementioned code will act like nothing is wrong and would just return <code class="language-plaintext highlighter-rouge">"1string"</code>, i.e. It will fail silently, not even a runtime error will be produced. Which is the last thing you would want.</p>

<p>A wise man once said:</p>

<blockquote>
  <p>Well engineered solutions fails early, fails fast, fails often.</p>
</blockquote>

<p>And I can’t emphasize enough how true this statement is.</p>

<p>You might argue that “no one would pass a string to a function called <code class="language-plaintext highlighter-rouge">add</code>, that’s too obvious”. I agree, however, think of a larger code base, many functions, classes, abstractions, on multiple modules. Things can get out of hands in JavaScript pretty quickly.</p>

<p>Have a look at this code for instance:</p>

<div class="language-javascript highlighter-rouge"><div class="highlight"><pre class="highlight"><code>
<span class="kd">function</span> <span class="nf">getAuthorLines</span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">return</span> <span class="nx">text</span><span class="p">.</span><span class="nf">match</span><span class="p">(</span><span class="sr">/^author: </span><span class="se">(</span><span class="sr">.*</span><span class="se">)</span><span class="sr">$/gmi</span><span class="p">);</span>
<span class="p">}</span>

<span class="kd">function</span> <span class="nf">getAuthorNames</span><span class="p">(</span><span class="nx">lines</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">return</span> <span class="nx">lines</span><span class="p">.</span><span class="nf">map</span><span class="p">((</span><span class="nx">line</span><span class="p">)</span><span class="o">=&gt;</span><span class="nx">line</span><span class="p">.</span><span class="nf">substr</span><span class="p">(</span><span class="mi">8</span><span class="p">))</span>
<span class="p">}</span>

<span class="kd">let</span> <span class="nx">text</span> <span class="o">=</span> <span class="dl">"</span><span class="s2">Paper title: TypeScript for the Win</span><span class="se">\n</span><span class="s2">Author: Alex Corvi</span><span class="se">\n</span><span class="s2">Author: John Doe</span><span class="se">\n</span><span class="s2">Author: Jane Doe</span><span class="se">\n</span><span class="dl">"</span><span class="p">;</span>

<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nf">getAuthorNames</span><span class="p">(</span><span class="nf">getAuthorLines</span><span class="p">(</span><span class="nx">text</span><span class="p">)));</span>

</code></pre></div></div>

<p>What do you expect the result to be? You guessed it, it’s:</p>

<div class="language-javascript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="p">[</span>
	<span class="dl">"</span><span class="s2">Alex Corvi</span><span class="dl">"</span><span class="p">,</span>
	<span class="dl">"</span><span class="s2">John Doe</span><span class="dl">"</span><span class="p">,</span>
	<span class="dl">"</span><span class="s2">Jane Doe</span><span class="dl">"</span><span class="p">,</span>
<span class="p">]</span>
</code></pre></div></div>

<p>Now add the following line:</p>

<div class="language-javascript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nf">getAuthorNames</span><span class="p">(</span><span class="nf">getAuthorLines</span><span class="p">(</span><span class="nx">text</span><span class="p">.</span><span class="nf">substr</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">30</span><span class="p">))));</span>
</code></pre></div></div>

<p>Ouch! That’s a runtime error! That’s because <code class="language-plaintext highlighter-rouge">String.match</code> doesn’t always return an array, it might return <code class="language-plaintext highlighter-rouge">null</code>.</p>

<p>Here’s another code, can you spot what’s wrong?</p>

<div class="language-javascript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">var</span> <span class="nx">theThing</span> <span class="o">=</span> <span class="kc">null</span><span class="p">;</span>
<span class="kd">var</span> <span class="nx">replaceThing</span> <span class="o">=</span> <span class="nf">function </span><span class="p">()</span> <span class="p">{</span>
	<span class="kd">var</span> <span class="nx">priorThing</span> <span class="o">=</span> <span class="nx">theThing</span><span class="p">;</span>
	<span class="kd">var</span> <span class="nx">unused</span> <span class="o">=</span> <span class="nf">function </span><span class="p">()</span> <span class="p">{</span>
		<span class="k">if </span><span class="p">(</span><span class="nx">priorThing</span><span class="p">)</span> <span class="p">{</span>
			<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="dl">"</span><span class="s2">hi</span><span class="dl">"</span><span class="p">);</span>
		<span class="p">}</span>
	<span class="p">};</span>
	<span class="nx">theThing</span> <span class="o">=</span> <span class="p">{</span>
		<span class="na">longStr</span><span class="p">:</span> <span class="k">new</span> <span class="nc">Array</span><span class="p">(</span><span class="mi">1000000</span><span class="p">).</span><span class="nf">join</span><span class="p">(</span><span class="dl">'</span><span class="s1">*</span><span class="dl">'</span><span class="p">),</span>
		<span class="na">someMethod</span><span class="p">:</span> <span class="nf">function </span><span class="p">()</span> <span class="p">{</span>
			<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="dl">"</span><span class="s2">abc</span><span class="dl">"</span><span class="p">);</span>
		<span class="p">}</span>
	<span class="p">};</span>
<span class="p">};</span>
<span class="nf">setInterval</span><span class="p">(</span><span class="nx">replaceThing</span><span class="p">,</span> <span class="mi">1000</span><span class="p">);</span>
</code></pre></div></div>

<p>That was a classic example of how you can cause memory leaks in JavaScript. This one leaks 1 MegaByte per second. In TypeScript, You can’t reassign the <code class="language-plaintext highlighter-rouge">theThing</code> variable from <code class="language-plaintext highlighter-rouge">null</code> to <code class="language-plaintext highlighter-rouge">Object</code>.</p>

<p>That doesn’t mean your applications will be bug-free. That’s never true, for any language. But surely, using TypeScript you can avoid a whole class of bugs.</p>

<p>One might argue, that being an experienced developer will help to avoid such bugs. Again, I agree, but:</p>

<ul>
  <li>TypeScript (or static typing in general) is like a seat belt, not matter how good driver you are, you should always wear one.</li>
  <li>The JavaScript community, is heavily reliant on modules (node modules) and those have a huge variance in quality.</li>
</ul>

<blockquote>
  <p>Static typing is like a seat belt, no matter how good driver you are, you should always wear one.</p>
</blockquote>

<h3 id="better-tooling-and-code-completion">Better tooling and code completion</h3>

<p>Code analysis, like abstract syntax trees, helps a lot with tooling. Code analysis is what makes code completion, linting, debugging tools, tree shaking tools possible. However, the dynamic nature of JavaScript makes it really hard for such tools to truly understand your code.</p>

<p>Take for example <a href="https://github.com/rollup/rollup">rollup</a>, a bundling tool, have been recently integrated into Vue.js and React, that is supposed to tree-shake your bundles making them lighter by removing inaccessible and dead code. The author of which, Rich Harris, <a href="https://github.com/rollup/rollup/wiki/Troubleshooting#tree-shaking-doesnt-seem-to-be-working">mentions</a>:</p>

<blockquote>
  <p>Because static analysis in a dynamic language like JavaScript is hard, there will occasionally be false positives […] Rollup’s static analysis will improve over time, but it will never be perfect in all cases – that’s just JavaScript.</p>
</blockquote>

<p>So there’s really a limit to what can be achieved in JavaScript tooling.</p>

<p>One of TypeScript’s goals was to remove such limits, and they sure did.</p>

<p>Here are my favorites:</p>

<ul>
  <li>Great code completion, with <strong>Intellisense</strong>.</li>
  <li>Goto symbol and show all symbols.</li>
  <li>Better code reformatting.</li>
  <li>A bunch of features that are provided with TSLint but not in ESLint.</li>
  <li><a href="https://johnpapa.net/refactoring-with-visual-studio-code/">Easy refactoring (e.g. renaming a symbol).</a></li>
</ul>

<blockquote>
  <p><strong>IntelliSense</strong> is the general term for a number of features: List Members, Parameter Info, Quick Info, and Complete Word. These features help you to learn more about the code you are using, keep track of the parameters you are typing, and add calls to properties and methods with only a few keystrokes.
Microsoft Developer Network</p>
</blockquote>

<h2 id="the-syntax">The Syntax</h2>

<h3 id="but-i-like-es6">But I like ES6…</h3>

<p>I hope I’ve convinced you enough to try out TypeScript. The syntax shouldn’t be alien to a JavaScript programmer. Especially those who have tried ES6/ES7.</p>

<p>TypeScript brands itself as a <em>“JavaScript Superset”</em>, so all valid JavaScript (ES3, ES5, ES6, ES7 …etc) is valid TypeScript. Everything you’ve been accustomed to, from flow controls to assignments.</p>

<p>So instead of having a totally new syntax (like PureScript, Elm and Dart), TypeScript builds on top of JavaScript syntax. Yet, it adds it’s own flavor on top.</p>

<h3 id="enough-talk-show-me-the-code">Enough talk, show me the code</h3>

<p>I can easily bet that all javascript developers will be able to understand the following piece of code:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code>
<span class="kd">let</span> <span class="nx">x</span><span class="p">:</span> <span class="kr">number</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
<span class="kd">let</span> <span class="nx">y</span><span class="p">:</span> <span class="kr">number</span> <span class="o">=</span> <span class="mi">500</span><span class="p">;</span>

<span class="kd">function</span> <span class="nf">getRand</span> <span class="p">(</span><span class="nx">min</span><span class="p">:</span> <span class="kr">number</span><span class="p">,</span> <span class="nx">max</span><span class="p">:</span> <span class="kr">number</span><span class="p">):</span> <span class="kr">number</span> <span class="p">{</span>
	<span class="k">return</span> <span class="nb">Math</span><span class="p">.</span><span class="nf">floor</span><span class="p">(</span><span class="nb">Math</span><span class="p">.</span><span class="nf">random</span><span class="p">()</span> <span class="o">*</span> <span class="p">(</span><span class="nx">max</span> <span class="o">-</span> <span class="nx">min</span><span class="p">))</span> <span class="o">+</span> <span class="nx">min</span><span class="p">;</span>
<span class="p">}</span>

<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nf">getRand</span><span class="p">(</span><span class="nx">x</span><span class="p">,</span> <span class="nx">y</span><span class="p">));</span>

</code></pre></div></div>

<p>So is this:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code>
<span class="kd">class</span> <span class="nc">House</span> <span class="p">{</span>
	<span class="nl">address</span><span class="p">:</span> <span class="kr">string</span><span class="p">;</span>
	<span class="nl">bedrooms</span><span class="p">:</span> <span class="kr">number</span><span class="p">;</span>
	<span class="nl">area</span><span class="p">:</span> <span class="kr">number</span><span class="p">;</span>
	<span class="nl">safeNeighborhood</span><span class="p">:</span><span class="nx">boolean</span><span class="p">;</span>
	<span class="nl">goodCondition</span><span class="p">:</span><span class="nx">boolean</span><span class="p">;</span>
	<span class="k">private</span> <span class="nx">priceCoefficient</span><span class="p">:</span> <span class="kr">number</span> <span class="o">=</span> <span class="mi">65</span><span class="p">;</span>
	<span class="kd">get</span> <span class="nf">price</span><span class="p">():</span> <span class="kr">number</span> <span class="p">{</span>
		<span class="k">return </span><span class="p">((</span><span class="k">this</span><span class="p">.</span><span class="nx">bedrooms</span> <span class="o">*</span> <span class="k">this</span><span class="p">.</span><span class="nx">area</span><span class="p">)</span> <span class="o">+</span>
			<span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="nx">safeNeighborhood</span> <span class="p">?</span> <span class="mi">1000</span> <span class="p">:</span> <span class="mi">0</span> <span class="p">)</span> <span class="o">+</span>
			<span class="p">(</span><span class="k">this</span><span class="p">.</span><span class="nx">goodCondition</span> <span class="p">?</span> <span class="mi">1000</span> <span class="p">:</span> <span class="mi">0</span> <span class="p">))</span> <span class="o">*</span> <span class="k">this</span><span class="p">.</span><span class="nx">priceCoefficient</span><span class="p">;</span>
	<span class="p">}</span>
<span class="p">}</span>

<span class="kd">let</span> <span class="nx">myHouse</span> <span class="o">=</span> <span class="k">new</span> <span class="nc">House</span><span class="p">();</span>
<span class="nx">myHouse</span><span class="p">.</span><span class="nx">bedrooms</span> <span class="o">=</span> <span class="mi">4</span><span class="p">;</span>
<span class="nx">myHouse</span><span class="p">.</span><span class="nx">area</span> <span class="o">=</span> <span class="mi">300</span><span class="p">;</span>
<span class="nx">myHouse</span><span class="p">.</span><span class="nx">safeNeighborhood</span> <span class="o">=</span> <span class="kc">true</span><span class="p">;</span>
<span class="nx">myHouse</span><span class="p">.</span><span class="nx">goodCondition</span> <span class="o">=</span> <span class="kc">true</span><span class="p">;</span>

<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nx">myHouse</span><span class="p">.</span><span class="nx">price</span><span class="p">)</span>

</code></pre></div></div>

<p>That was a major portion of what you’ll find in a TypeScript project.</p>

<h3 id="interfaces">Interfaces</h3>

<p>Interfaces, simply put, is a way to declare JSON object types.</p>

<p>You can write your object type definition like this:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">let</span> <span class="nx">myObj</span><span class="p">:</span> <span class="p">{</span> <span class="nl">a</span><span class="p">:</span> <span class="kr">number</span><span class="p">;</span> <span class="nl">str</span><span class="p">:</span> <span class="kr">string</span><span class="p">;</span> <span class="p">}</span> <span class="o">=</span> <span class="p">{</span>
	<span class="na">a</span><span class="p">:</span> <span class="mi">123</span><span class="p">,</span>
	<span class="na">str</span><span class="p">:</span> <span class="dl">"</span><span class="s2">my string</span><span class="dl">"</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Or you can declare a re-usable interface:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kr">interface</span> <span class="nx">MyObj</span> <span class="p">{</span>
	<span class="nl">a</span><span class="p">:</span> <span class="kr">number</span><span class="p">;</span>
	<span class="nl">str</span><span class="p">:</span> <span class="kr">string</span><span class="p">;</span>
<span class="p">}</span>

<span class="kd">let</span> <span class="nx">myObj1</span><span class="p">:</span> <span class="nx">MyObj</span> <span class="o">=</span> <span class="p">{</span>
	<span class="na">a</span><span class="p">:</span> <span class="mi">123</span><span class="p">,</span>
	<span class="na">str</span><span class="p">:</span> <span class="dl">"</span><span class="s2">string</span><span class="dl">"</span>
<span class="p">}</span>


<span class="kd">let</span> <span class="nx">myObj2</span><span class="p">:</span> <span class="nx">MyObj</span> <span class="o">=</span> <span class="p">{</span>
	<span class="na">a</span><span class="p">:</span> <span class="mi">456</span><span class="p">,</span>
	<span class="na">str</span><span class="p">:</span> <span class="dl">"</span><span class="s2">another string</span><span class="dl">"</span>
<span class="p">}</span>
</code></pre></div></div>

<h3 id="compilation">Compilation</h3>

<p>To be able to work in the browser &amp; node, TypeScript compiles to JavaScript. Now you may have this preconceived notion of the compiled code being unreadable and uglified, but reality is exactly the opposite.</p>

<p>After type-checking, the compiler will emit very clean and readable code. So this:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">let</span> <span class="nx">x</span><span class="p">:</span> <span class="kr">number</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
<span class="kd">let</span> <span class="nx">y</span><span class="p">:</span> <span class="kr">number</span> <span class="o">=</span> <span class="mi">500</span><span class="p">;</span>
<span class="kd">function</span> <span class="nf">getRand</span> <span class="p">(</span><span class="nx">min</span><span class="p">:</span> <span class="kr">number</span><span class="p">,</span> <span class="nx">max</span><span class="p">:</span> <span class="kr">number</span><span class="p">):</span> <span class="kr">number</span> <span class="p">{</span>
	<span class="k">return</span> <span class="nb">Math</span><span class="p">.</span><span class="nf">floor</span><span class="p">(</span><span class="nb">Math</span><span class="p">.</span><span class="nf">random</span><span class="p">()</span> <span class="o">*</span> <span class="p">(</span><span class="nx">max</span> <span class="o">-</span> <span class="nx">min</span><span class="p">))</span> <span class="o">+</span> <span class="nx">min</span><span class="p">;</span>
<span class="p">}</span>
<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nf">getRand</span><span class="p">(</span><span class="nx">x</span><span class="p">,</span> <span class="nx">y</span><span class="p">));</span>
</code></pre></div></div>

<p>Will compile to this:</p>

<div class="language-javascript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">var</span> <span class="nx">x</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
<span class="kd">var</span> <span class="nx">y</span> <span class="o">=</span> <span class="mi">500</span><span class="p">;</span>
<span class="kd">function</span> <span class="nf">getRand</span><span class="p">(</span><span class="nx">min</span><span class="p">,</span> <span class="nx">max</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">return</span> <span class="nb">Math</span><span class="p">.</span><span class="nf">floor</span><span class="p">(</span><span class="nb">Math</span><span class="p">.</span><span class="nf">random</span><span class="p">()</span> <span class="o">*</span> <span class="p">(</span><span class="nx">max</span> <span class="o">-</span> <span class="nx">min</span><span class="p">))</span> <span class="o">+</span> <span class="nx">min</span><span class="p">;</span>
<span class="p">}</span>
<span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="nf">getRand</span><span class="p">(</span><span class="nx">x</span><span class="p">,</span> <span class="nx">y</span><span class="p">));</span>
</code></pre></div></div>

<p>Have a look at the <a href="http://www.typescriptlang.org/play/">TypeScript Playground</a> where you can compile TypeScript immediately in your browser. Yes, it’s being compiled in the browser. This is possible since the TypeScript compiler is written in TypeScript.</p>

<p>And while you’re at it, you’ll notice 2 things:</p>

<ul>
  <li>TypeScript compiler is really fast!</li>
  <li>You can compile your ES6/ES7 code all the way down to ES3. No Babel required.</li>
</ul>

<blockquote>
  <p>You won’t have to use Babel/buble anymore. TypeScript bridges the gap between the recent versions of JavaScript and what’s available on every modern browser, by compiling your code down to even ES3. However, you still have the option to compile to any ES version you like.</p>
</blockquote>

<h2 id="type-inference">Type inference</h2>

<p>One of the killer features of TypeScript, is a really good type inference. Meaning that sometimes you won’t even have to declare some of the types.</p>

<p>For example:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code>
<span class="kd">let</span> <span class="nx">a</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="c1">// inferred as a number</span>
<span class="kd">let</span> <span class="nx">str</span> <span class="o">=</span> <span class="dl">"</span><span class="s2">string</span><span class="dl">"</span><span class="p">;</span> <span class="c1">// inferred as a string</span>

<span class="c1">// function return type will also be inferred</span>
<span class="kd">function</span> <span class="nf">add</span> <span class="p">(</span><span class="nx">a</span><span class="p">:</span><span class="kr">number</span><span class="p">,</span> <span class="nx">b</span><span class="p">:</span><span class="kr">number</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">return</span> <span class="nx">a</span> <span class="o">+</span> <span class="nx">b</span><span class="p">;</span>
<span class="p">}</span>

<span class="kd">let</span> <span class="nx">b</span> <span class="o">=</span> <span class="nf">add</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">);</span> <span class="c1">// type inferred as a number</span>
<span class="kd">let</span> <span class="nx">x</span> <span class="o">=</span> <span class="nf">add</span><span class="p">(</span><span class="nx">c</span><span class="p">,</span> <span class="nx">b</span><span class="p">);</span> <span class="c1">// compiler will produce an error</span>
</code></pre></div></div>

<p>Another advanced example:</p>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// Notice how we won't declare any types:</span>
<span class="kd">function</span> <span class="nf">myFunc</span> <span class="p">(</span><span class="nx">param</span><span class="p">)</span> <span class="p">{</span>
	<span class="k">return</span> <span class="p">{</span>
		<span class="na">n</span><span class="p">:</span> <span class="mi">0</span><span class="p">,</span>
		<span class="na">str</span><span class="p">:</span> <span class="dl">"</span><span class="s2">myString</span><span class="dl">"</span><span class="p">,</span>
		<span class="na">obj</span><span class="p">:</span> <span class="p">{</span>
			<span class="na">obj</span><span class="p">:</span> <span class="p">{</span>
				<span class="na">obj</span><span class="p">:</span> <span class="p">{</span>
					<span class="na">someVal</span><span class="p">:</span> <span class="nx">param</span> <span class="o">&gt;</span> <span class="mi">5</span> <span class="p">?</span> <span class="dl">"</span><span class="s2">myString</span><span class="dl">"</span> <span class="p">:</span> <span class="nx">param</span> <span class="o">&gt;</span> <span class="mi">4</span> <span class="p">?</span> <span class="p">{</span><span class="na">a</span><span class="p">:</span><span class="mi">5</span><span class="p">}</span> <span class="p">:</span> <span class="p">[</span><span class="dl">"</span><span class="s2">myString</span><span class="dl">"</span><span class="p">,</span> <span class="mi">14</span><span class="p">]</span>
				<span class="p">}</span>
			<span class="p">}</span>
		<span class="p">}</span>
	<span class="p">}</span>
<span class="p">}</span>
<span class="c1">// hover over someVal</span>
<span class="nf">myFunc</span><span class="p">(</span><span class="mi">10</span><span class="p">).</span><span class="nx">obj</span><span class="p">.</span><span class="nx">obj</span><span class="p">.</span><span class="nx">obj</span><span class="p">.</span><span class="nx">someVal</span>
</code></pre></div></div>

<p>Now when hovering over <code class="language-plaintext highlighter-rouge">someVal</code> you’ll notice that it’s type is declared as:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>string | Array&lt;string|number&gt; | {a: number;}
</code></pre></div></div>

<p><a href="https://goo.gl/Zw11Yv">Try it</a></p>

<h2 id="node-and-typescript">Node and TypeScript</h2>

<p>Node.JS support was a priority when developing TypeScript. Your TypeScript code can be distributed as a node module, consumed in JavaScript just like any JavaScript module, and consumed in TypeScript with type declarations included, all while writing only once.</p>

<h3 id="authoring-and-distributing-typescript-node-modules">Authoring and distributing TypeScript Node Modules</h3>

<p>When compiling your javascript you can tell the compiler to emit type definitions (only type definitions, no logic) in a separate file that can be discoverable by TypeScript, yet does not affect your module when consumed in a JavaScript project (unless your editor wanted to be smart about it).</p>

<p>All that you have to do is include the <code class="language-plaintext highlighter-rouge">declaration:true</code> in your <code class="language-plaintext highlighter-rouge">tsconfig.json</code> file:</p>

<div class="language-javascript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="p">{</span>
	<span class="dl">"</span><span class="s2">declarations</span><span class="dl">"</span><span class="p">:</span><span class="kc">true</span>
<span class="p">}</span>
</code></pre></div></div>

<p>then refer to this file in your <code class="language-plaintext highlighter-rouge">package.json</code>:</p>

<div class="language-javascript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="p">{</span>
	<span class="dl">"</span><span class="s2">types</span><span class="dl">"</span><span class="p">:</span><span class="dl">"</span><span class="s2">./dist/index.d.ts</span><span class="dl">"</span>
<span class="p">}</span>
</code></pre></div></div>

<h3 id="consuming-javascript-node-modules-in-typescript">Consuming JavaScript Node Modules In TypeScript</h3>

<p>What if you wanted to consume a module that was written in JavaScript? Express for example. Your editor (e.g. VSCode) can only try to have an idea about the imported module, but as we’ve discussed above, tools are actually limited by the dynamic nature of JavaScript.</p>

<p>So your best bet is head to <a href="https://github.com/DefinitelyTyped/DefinitelyTyped">the DefinitelyTyped repository</a> and find if a there’s a type definition for the module you’re consuming.</p>

<p>The good news is that <a href="https://github.com/DefinitelyTyped/DefinitelyTyped">the DefinitelyTyped repository</a> have over 3000 modules. Chances are you’re going to find the module you’re about to use.</p>

<h4 id="example-consuming-express-in-typescript">Example: Consuming Express in TypeScript</h4>

<p>Install the types:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>npm i --save-dev @types/express
</code></pre></div></div>

<div class="language-typescript highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// import</span>
<span class="k">import</span> <span class="p">{</span> <span class="nx">Request</span><span class="p">,</span> <span class="nx">Response</span><span class="p">,</span> <span class="nx">NextFunction</span> <span class="p">}</span> <span class="k">from</span> <span class="dl">"</span><span class="s2">@types/express</span><span class="dl">"</span><span class="p">;</span>
<span class="c1">// declare</span>
<span class="kd">function</span> <span class="nf">myMiddleWare</span> <span class="p">(</span><span class="nx">req</span><span class="p">:</span> <span class="nx">Request</span><span class="p">,</span> <span class="nx">res</span><span class="p">:</span> <span class="nx">Response</span><span class="p">,</span> <span class="nx">next</span><span class="p">:</span><span class="nx">NextFunction</span><span class="p">)</span> <span class="p">{</span>
	<span class="c1">// middleware code</span>
<span class="p">}</span>
</code></pre></div></div>

<h2 id="react-and-typescript">React and TypeScript</h2>

<p>TypeScript, being an open-source community driven project, have added support for react in a really nice way.</p>

<p>Just like you’re going to rename your <code class="language-plaintext highlighter-rouge">.js</code> files to <code class="language-plaintext highlighter-rouge">.ts</code>, your <code class="language-plaintext highlighter-rouge">.jsx</code> files should be <code class="language-plaintext highlighter-rouge">.tsx</code>. And that’s it, now install React’s type declarations from the definitely typed repository, and feel how good it is to have everything in your project to be strong-typed. Yes! Even HTML! and CSS!</p>

<h2 id="dart-flow-purescript-elm">Dart, Flow, PureScript, Elm</h2>

<ul>
  <li><strong>Flow</strong>: Is a facebook product. However, it’s not a language, it’s just a type-checker. TypeScript does what Flow does in addition to many other features. Also it has a larger community.</li>
  <li><strong>Dart</strong>: Although very powerful, but Dart’s syntax is different from JavaScript. I think that’s the main reason why it didn’t catch up with the community as TypeScript did. TypeScript embraced the new ES6/ES7 features and built it’s foundation on top of them.</li>
  <li><strong>PureScript</strong> &amp; <strong>Elm</strong>: Are trying to achieve different thing, pure functional programming language, that compiles to JavaScript.</li>
</ul>

<h2 id="closing-statement">Closing statement</h2>

<p>I’ve been developing with JavaScript for at least 5 years. However, After trying TypeScript for merly 4 months, working with JavaScript feels like walking on thin ice, you may make it for 10 meters or so, but you shouldn’t go any longer.</p>

<p>I can now understand why there are so many well-educated developers disliking the dynamic nature of JavaScript.</p>

<h2 id="resources">Resources</h2>

<ul>
  <li><a href="http://www.typescriptlang.org/docs/tutorial.html">The official documentation</a>.</li>
  <li>Anders Hejlsberg Talks about TypeScript: <a href="http://video.ch9.ms/ch9/4ae3/062c336d-9cf0-498f-ae9a-582b87954ae3/B881_mid.mp4">1</a> <a href="https://www.youtube.com/watch?v=s0ecDXWvLmU">2</a> <a href="https://www.youtube.com/watch?v=eX2PXjj-KDk">3</a>.</li>
  <li><a href="http://definitelytyped.org/">Definitely Typed</a>.</li>
  <li>Editors and IDEs plugins: <a href="https://github.com/Microsoft/TypeScript-Sublime-Plugin">Sublime Text</a> <a href="https://atom.io/packages/atom-typescript">Atom</a> <a href="https://github.com/palantir/eclipse-typescript">Eclipse</a> <a href="https://github.com/Microsoft/TypeScript/wiki/TypeScript-Editor-Support#vim">Vim</a>.</li>
</ul>]]></content><author><name>Alex Corvi</name></author><category term="TypeScript" /><summary type="html"><![CDATA[I was introduced to TypeScript when it first came with angular 2. However, I tried to avoid it as much as possible. This was actually the main reason of why I left angular in favor of Vue. “A new quirky front-end language is the last thing I would need,” I thought.]]></summary></entry><entry><title type="html">Rust for High-Level Programming Language Developers</title><link href="/Rust-for-High-Level-Programming-Language-Developers/" rel="alternate" type="text/html" title="Rust for High-Level Programming Language Developers" /><published>2017-04-12T05:00:00+00:00</published><updated>2017-04-12T05:00:00+00:00</updated><id>/Rust%20for%20High-Level%20Programming%20Language%20Developers</id><content type="html" xml:base="/Rust-for-High-Level-Programming-Language-Developers/"><![CDATA[<p>So you’ve been doing high-level programming all your life, and you’ve been eyeing Rust for some time now, and you’re not sure where to start (or how to start). Well, this walk-through-like post will guide you through some of the common tasks you preform in high-level languages like JavaScript, Python, or even C#.</p>

<h3 id="so-json-in-rust">So, JSON in Rust?</h3>
<h4 id="the-short-answer-is-no-built-in-support-for-json-but">The short answer is ‘no built-in support for JSON but…’</h4>
<p>Well, Rust has no built-in support for JSON objects, but before you let that throw you off, Rust <code class="language-plaintext highlighter-rouge">struct</code>s are ~ 99% identical to JSON objects in their outer structure and the way they are defined and used. Let’s look at an example.</p>

<p>Say you want to define a Person JSON object with fields holding things like the <code class="language-plaintext highlighter-rouge">full name</code>, <code class="language-plaintext highlighter-rouge">date of birth</code>, and <code class="language-plaintext highlighter-rouge">gender</code> of a person. Here’s how you’d likely define your object in a language like JavaScript:</p>

<div class="language-js highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">var</span> <span class="nx">person</span> <span class="o">=</span> <span class="p">{</span>
  <span class="na">fullName</span><span class="p">:</span> <span class="dl">'</span><span class="s1">Fadi Hanna Al-Kass</span><span class="dl">'</span><span class="p">,</span>
  <span class="na">dateOfBirth</span><span class="p">:</span> <span class="dl">'</span><span class="s1">01-01-1990</span><span class="dl">'</span><span class="p">,</span>
  <span class="na">gender</span><span class="p">:</span> <span class="dl">'</span><span class="s1">MALE</span><span class="dl">'</span>
<span class="p">};</span>
</code></pre></div></div>

<p>Here’s how you’d write this in Rust:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// Our pseudo-JSON object skeleton</span>
<span class="k">struct</span> <span class="n">Person</span> <span class="p">{</span>
  <span class="n">full_name</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span>
  <span class="n">date_of_birth</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span>
  <span class="n">gender</span><span class="p">:</span> <span class="nb">String</span>
<span class="p">}</span>

<span class="k">fn</span> <span class="nf">main</span> <span class="p">()</span> <span class="p">{</span>
  <span class="k">let</span> <span class="n">person</span> <span class="o">=</span> <span class="n">Person</span> <span class="p">{</span>
    <span class="n">full_name</span><span class="p">:</span> <span class="s">"Fadi Hanna Al-Kass"</span><span class="nf">.to_string</span><span class="p">(),</span>
    <span class="n">date_of_birth</span><span class="p">:</span> <span class="s">"01-01-1990"</span><span class="nf">.to_string</span><span class="p">(),</span>
    <span class="n">gender</span><span class="p">:</span> <span class="s">"MALE"</span><span class="nf">.to_string</span><span class="p">()</span>
  <span class="p">};</span>
<span class="p">}</span>
</code></pre></div></div>

<p>You’ve probably already noticed two differences between the two code snippets:</p>

<ol>
  <li>We had to define a skeleton for our pseudo-JSON object.</li>
  <li>We used lowerCamelCase with JavaScript and snake_case with our Rust code snippet. This is really nothing more than a naming convention that the Rust compiler will throw a bunch of warnings at you if you don’t follow, but it shouldn’t have an effect on the execution of your program if you so choose not to follow.</li>
</ol>

<p>Now back to the first (and perhaps, more obvious) difference. Rust is a very (and I mean very) strongly typed programming language. That said, it needs to own as much information about your object types during the compilation process as possible. Of course, <code class="language-plaintext highlighter-rouge">struct</code>s are no exception, and you can really consider two ways (or more, depending on how imaginational you are) of looking at this: it is either (1) <code class="language-plaintext highlighter-rouge">limiting</code> or (2) <code class="language-plaintext highlighter-rouge">validating</code>. I wouldn’t be putting this post together had I considered strong-typing limiting.</p>

<blockquote>
  <p>You can always replace a strongly typed pseudo-JSON object with a <code class="language-plaintext highlighter-rouge">HashMap</code> to get around the static typing issue, but I’d advice against that, and I believe I can convince you to stick to the <code class="language-plaintext highlighter-rouge">struct</code> approach. You may, at this point, still not think so, but wait until we get to these magical little thingies called <code class="language-plaintext highlighter-rouge">traits</code> and then we’ll see ;-)</p>
</blockquote>

<h3 id="nested-pseudo-json-objects">Nested pseudo-JSON Objects?</h3>
<h4 id="sure-forward-we-go">Sure, forward we go</h4>

<p>Let’s design our <code class="language-plaintext highlighter-rouge">Person</code> JSON object in a more modern fashion. Instead of having a field containing the <code class="language-plaintext highlighter-rouge">full_name</code>, we can turn <code class="language-plaintext highlighter-rouge">full_name</code> into a sub-<code class="language-plaintext highlighter-rouge">struct</code> that has two fields (<code class="language-plaintext highlighter-rouge">first_name</code> and <code class="language-plaintext highlighter-rouge">last_name</code>). Instead of storing <code class="language-plaintext highlighter-rouge">date_of_birth</code> as a string that we may, at some point, need to parse down to extract the day, month, and the year from, we can store this information in a <code class="language-plaintext highlighter-rouge">struct</code> with three separate fields. And for our <code class="language-plaintext highlighter-rouge">gender</code> field, we can reference an <code class="language-plaintext highlighter-rouge">enum</code> value.</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">struct</span> <span class="n">FullName</span> <span class="p">{</span>
    <span class="n">first_name</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span>
    <span class="n">last_name</span><span class="p">:</span> <span class="nb">String</span>
<span class="p">}</span>

<span class="k">struct</span> <span class="n">DateOfBirth</span> <span class="p">{</span>
    <span class="n">day</span><span class="p">:</span> <span class="nb">i8</span><span class="p">,</span>  <span class="c1">// 8-bit integer variable</span>
    <span class="n">month</span><span class="p">:</span> <span class="nb">i8</span><span class="p">,</span>
    <span class="n">year</span><span class="p">:</span> <span class="nb">i16</span> <span class="c1">// 16-bit integer variable</span>
<span class="p">}</span>

<span class="k">enum</span> <span class="n">Gender</span> <span class="p">{</span>
    <span class="n">MALE</span><span class="p">,</span>
    <span class="n">FEMALE</span><span class="p">,</span>
    <span class="n">NotDisclosed</span>
<span class="p">}</span>

<span class="k">struct</span> <span class="n">Person</span> <span class="p">{</span>
  <span class="n">full_name</span><span class="p">:</span> <span class="n">FullName</span><span class="p">,</span>
  <span class="n">date_of_birth</span><span class="p">:</span> <span class="n">DateOfBirth</span><span class="p">,</span>
  <span class="n">gender</span><span class="p">:</span> <span class="n">Gender</span>
<span class="p">}</span>

<span class="k">fn</span> <span class="nf">main</span> <span class="p">()</span> <span class="p">{</span>
  <span class="k">let</span> <span class="n">person</span> <span class="o">=</span> <span class="n">Person</span> <span class="p">{</span>
      <span class="n">full_name</span><span class="p">:</span> <span class="n">FullName</span> <span class="p">{</span>
          <span class="n">first_name</span><span class="p">:</span> <span class="s">"Fadi"</span><span class="nf">.to_string</span><span class="p">(),</span>
          <span class="n">last_name</span><span class="p">:</span> <span class="s">"Hanna Al-Kass"</span><span class="nf">.to_string</span><span class="p">()</span>
      <span class="p">},</span>
      <span class="n">date_of_birth</span><span class="p">:</span> <span class="n">DateOfBirth</span> <span class="p">{</span>
          <span class="n">day</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>
          <span class="n">month</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>
          <span class="n">year</span><span class="p">:</span> <span class="mi">1990</span>
      <span class="p">},</span>
      <span class="n">gender</span><span class="p">:</span> <span class="nn">Gender</span><span class="p">::</span><span class="n">MALE</span>
  <span class="p">};</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Our pseudo-JSON object is now looking much cleaner and even easier to utilize. Speaking of utilization, how do we reference our fields? Well, you’ve probably guessed it already. Yes, it’s the dot operator. If you’re interested in, say, printing the full name of your Person object, here’s how you’d do that:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// The following line of code goes inside your main function right after</span>
<span class="c1">// your person object has been instantiated, or really anywhere after the</span>
<span class="c1">// object has been declared.</span>

<span class="nd">println!</span><span class="p">(</span><span class="s">"{} {}"</span><span class="p">,</span> <span class="n">person</span><span class="py">.full_name.first_name</span><span class="p">,</span> <span class="n">person</span><span class="py">.full_name.last_name</span><span class="p">);</span>
</code></pre></div></div>

<p>and you’re probably seeing a problem here already. It would be absolutely tedious to use this approach to print out the full name of a person especially if you were to do this from multiple places in your program let alone the fact the way the print is done looks really primitive. There must be a different (perhaps, even, better) way you say. You bet there is. In fact, there not only is but are many ways you can go about handling this issue, which one of which would be the use of <code class="language-plaintext highlighter-rouge">traits</code>. A trait is a programmatical way of telling the compiler how to carry out specific functionalities during the build process. We’re going to use one here and learn how to write our own further below. The trait we’re about to use in a moment is called the <code class="language-plaintext highlighter-rouge">Debug</code> trait which basically sets out a specific printing layout for your defined <code class="language-plaintext highlighter-rouge">enum</code>, <code class="language-plaintext highlighter-rouge">struct</code> or what have you.</p>

<p>If you simply add <code class="language-plaintext highlighter-rouge">#[derive(Debug)]</code> right on top of your <code class="language-plaintext highlighter-rouge">FullName</code> <code class="language-plaintext highlighter-rouge">struct</code> definition: i.e.:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nd">#[derive(Debug)]</span>
<span class="k">struct</span> <span class="n">FullName</span> <span class="p">{</span>
    <span class="n">first_name</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span>
    <span class="n">last_name</span><span class="p">:</span> <span class="nb">String</span>
<span class="p">}</span>
</code></pre></div></div>

<p>and replace:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nd">println!</span><span class="p">(</span><span class="s">"{} {}"</span><span class="p">,</span> <span class="n">person</span><span class="py">.full_name.first_name</span><span class="p">,</span> <span class="n">person</span><span class="py">.full_name.last_name</span><span class="p">);</span>
</code></pre></div></div>

<p>with:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nd">println!</span><span class="p">(</span><span class="s">"{:?}"</span><span class="p">,</span> <span class="n">person</span><span class="py">.full_name</span><span class="p">);</span>
</code></pre></div></div>

<p>You’ll end up with:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">FullName</span> <span class="p">{</span> <span class="n">first_name</span><span class="p">:</span> <span class="s">"Fadi"</span><span class="p">,</span> <span class="n">last_name</span><span class="p">:</span> <span class="s">"Hanna Al-Kass"</span> <span class="p">}</span>
</code></pre></div></div>

<p>Cool, isn’t it? Well, it gets even cooler in a bit.</p>

<p>But hang on a second, why did I have to replace <code class="language-plaintext highlighter-rouge">{}</code> with <code class="language-plaintext highlighter-rouge">{:?}</code> in my <code class="language-plaintext highlighter-rouge">println</code> statement? Or an even more proper question to ask is: what is the difference between the two?
Well, so Rust has two ways of printing out stuff (there might be even more ways I am yet to discover!): a (1) <code class="language-plaintext highlighter-rouge">Display</code> and a <code class="language-plaintext highlighter-rouge">Debug</code>. <code class="language-plaintext highlighter-rouge">Display</code> is what you’d probably want to use to allow the program to communicate some meaningful output to your user, and <code class="language-plaintext highlighter-rouge">Debug</code> is what you could use during the development process. These two <code class="language-plaintext highlighter-rouge">traits</code> can co-exist without overlapping each other. By that I mean you can allow your object to print something with <code class="language-plaintext highlighter-rouge">{}</code> and something entirely different with <code class="language-plaintext highlighter-rouge">{:?}</code>, but that’s to be covered when we get down to writing our own <code class="language-plaintext highlighter-rouge">trait</code>s.</p>

<p>So is it possible to use <code class="language-plaintext highlighter-rouge">#[derive(Debug)]</code> to print out nested objects? Yes, it is, and following is how. Simply add <code class="language-plaintext highlighter-rouge">#[derive(Debug)]</code> right on top of your main object and every object that’s part of it and then print the object as a whole by passing it to a  <code class="language-plaintext highlighter-rouge">println</code> function using the <code class="language-plaintext highlighter-rouge">{:?}</code> notation, i.e.:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nd">#[derive(Debug)]</span>
<span class="k">struct</span> <span class="n">FullName</span> <span class="p">{</span>
    <span class="n">first_name</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span>
    <span class="n">last_name</span><span class="p">:</span> <span class="nb">String</span>
<span class="p">}</span>

<span class="nd">#[derive(Debug)]</span>
<span class="k">struct</span> <span class="n">DateOfBirth</span> <span class="p">{</span>
    <span class="n">day</span><span class="p">:</span> <span class="nb">i8</span><span class="p">,</span>  <span class="c1">// 8-bit integer variable</span>
    <span class="n">month</span><span class="p">:</span> <span class="nb">i8</span><span class="p">,</span>
    <span class="n">year</span><span class="p">:</span> <span class="nb">i16</span> <span class="c1">// 16-bit integer variable</span>
<span class="p">}</span>

<span class="nd">#[derive(Debug)]</span>
<span class="k">enum</span> <span class="n">Gender</span> <span class="p">{</span>
    <span class="n">MALE</span><span class="p">,</span>
    <span class="n">FEMALE</span><span class="p">,</span>
    <span class="n">NotDisclosed</span>
<span class="p">}</span>

<span class="nd">#[derive(Debug)]</span>
<span class="k">struct</span> <span class="n">Person</span> <span class="p">{</span>
  <span class="n">full_name</span><span class="p">:</span> <span class="n">FullName</span><span class="p">,</span>
  <span class="n">date_of_birth</span><span class="p">:</span> <span class="n">DateOfBirth</span><span class="p">,</span>
  <span class="n">gender</span><span class="p">:</span> <span class="n">Gender</span>
<span class="p">}</span>

<span class="k">fn</span> <span class="nf">main</span> <span class="p">()</span> <span class="p">{</span>
  <span class="k">let</span> <span class="n">person</span> <span class="o">=</span> <span class="n">Person</span> <span class="p">{</span>
      <span class="n">full_name</span><span class="p">:</span> <span class="n">FullName</span> <span class="p">{</span>
          <span class="n">first_name</span><span class="p">:</span> <span class="s">"Fadi"</span><span class="nf">.to_string</span><span class="p">(),</span>
          <span class="n">last_name</span><span class="p">:</span> <span class="s">"Hanna Al-Kass"</span><span class="nf">.to_string</span><span class="p">()</span>
      <span class="p">},</span>
      <span class="n">date_of_birth</span><span class="p">:</span> <span class="n">DateOfBirth</span> <span class="p">{</span>
          <span class="n">day</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>
          <span class="n">month</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span>
          <span class="n">year</span><span class="p">:</span> <span class="mi">1990</span>
      <span class="p">},</span>
      <span class="n">gender</span><span class="p">:</span> <span class="nn">Gender</span><span class="p">::</span><span class="n">MALE</span>
  <span class="p">};</span>
  <span class="nd">println!</span><span class="p">(</span><span class="s">"{:?}"</span><span class="p">,</span> <span class="n">person</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div></div>

<p>And your output will look like:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">Person</span> <span class="p">{</span> <span class="n">full_name</span><span class="p">:</span> <span class="n">FullName</span> <span class="p">{</span> <span class="n">first_name</span><span class="p">:</span> <span class="s">"Fadi"</span><span class="p">,</span> <span class="n">last_name</span><span class="p">:</span> <span class="s">"Hanna Al-Kass"</span> <span class="p">},</span> <span class="n">date_of_birth</span><span class="p">:</span> <span class="n">DateOfBirth</span> <span class="p">{</span> <span class="n">day</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="n">month</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="n">year</span><span class="p">:</span> <span class="mi">1990</span> <span class="p">},</span> <span class="n">gender</span><span class="p">:</span> <span class="n">MALE</span> <span class="p">}</span>
</code></pre></div></div>

<p>Our output is looking pretty verbose already, and you may not like that. Is there a way to manipulate this output in terms of re-arranging its layout or limiting the amount of information being displayed? You bet there is, and it’s through writing our own <code class="language-plaintext highlighter-rouge">Debug</code> <code class="language-plaintext highlighter-rouge">trait</code> instead of using a <code class="language-plaintext highlighter-rouge">derive</code>d one. I think it’s better to introduce one more thing right before we get down to business with <code class="language-plaintext highlighter-rouge">trait</code>s, and that is Rust’s <code class="language-plaintext highlighter-rouge">OOP</code>-like paradigm. I call it <code class="language-plaintext highlighter-rouge">OOP</code>-like because Rust doesn’t consider itself an Object-Oriented Programming Language, but sure that in no way means we can’t do <code class="language-plaintext highlighter-rouge">OOP</code> in Rust. It just means <code class="language-plaintext highlighter-rouge">OOP</code> is done differently. To be more precise, <code class="language-plaintext highlighter-rouge">OOP</code> in Rust is done in a way Rust wouldn’t consider <code class="language-plaintext highlighter-rouge">OOP</code>.</p>

<p>Up until now, we’ve only been working with <code class="language-plaintext highlighter-rouge">struct</code>s and <code class="language-plaintext highlighter-rouge">enum</code>s. You’ve probably already noticed that we used them to store data, but no logic (constructors, functions, destructors, etc) was added to them. That’s because that’s not where the functions go. before I further explain this, let’s look at a tiny Python class and discuss how its alternative can be written in Rust.
Say you have a <code class="language-plaintext highlighter-rouge">Person</code> <code class="language-plaintext highlighter-rouge">class</code> with a constructor that takes a <code class="language-plaintext highlighter-rouge">first_name</code> and a <code class="language-plaintext highlighter-rouge">last_name</code> and provides two separate getter functions that give you these two string values whenever you need them. You’d write your class something as follows:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">class</span> <span class="nc">Person</span><span class="p">:</span>
  <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="n">self</span><span class="p">,</span> <span class="n">firstName</span><span class="p">,</span> <span class="n">lastName</span><span class="p">):</span>
    <span class="n">self</span><span class="p">.</span><span class="n">firstName</span> <span class="o">=</span> <span class="n">firstName</span>
    <span class="n">self</span><span class="p">.</span><span class="n">lastName</span> <span class="o">=</span> <span class="n">lastName</span>
  <span class="k">def</span> <span class="nf">getFirstName</span><span class="p">(</span><span class="n">self</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">self</span><span class="p">.</span><span class="n">firstName</span>
  <span class="k">def</span> <span class="nf">getLastName</span><span class="p">(</span><span class="n">self</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">self</span><span class="p">.</span><span class="n">lastName</span>
</code></pre></div></div>

<p>Notice how we have our fields and functions mixed together inside a single class. Rust separates the two. You’d have your fields defined inside a <code class="language-plaintext highlighter-rouge">struct</code> and an <code class="language-plaintext highlighter-rouge">impl</code> containing all relevant functions. So, when interpreted, our Python class would look in Rust as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">struct</span> <span class="n">Person</span> <span class="p">{</span>
    <span class="n">first_name</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span>
    <span class="n">last_name</span><span class="p">:</span> <span class="nb">String</span>
<span class="p">}</span>

<span class="k">impl</span> <span class="n">Person</span> <span class="p">{</span>
    <span class="k">fn</span> <span class="nf">new</span> <span class="p">(</span><span class="n">first_name</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span> <span class="n">last_name</span><span class="p">:</span> <span class="nb">String</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="n">Person</span> <span class="p">{</span>
        <span class="k">return</span> <span class="n">Person</span> <span class="p">{</span>
            <span class="n">first_name</span><span class="p">:</span> <span class="n">first_name</span><span class="p">,</span>
            <span class="n">last_name</span><span class="p">:</span> <span class="n">last_name</span>
        <span class="p">};</span>
    <span class="p">}</span>
    <span class="k">fn</span> <span class="nf">get_first_name</span> <span class="p">(</span><span class="o">&amp;</span><span class="k">self</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="o">&amp;</span><span class="nb">str</span> <span class="p">{</span>
        <span class="k">return</span> <span class="o">&amp;</span><span class="k">self</span><span class="py">.first_name</span><span class="p">;</span>
    <span class="p">}</span>

    <span class="k">fn</span> <span class="nf">get_last_name</span> <span class="p">(</span><span class="o">&amp;</span><span class="k">self</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="o">&amp;</span><span class="nb">str</span> <span class="p">{</span>
        <span class="k">return</span> <span class="o">&amp;</span><span class="k">self</span><span class="py">.last_name</span>
    <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<p>And to instantiate the object and access/utilize its functions, we do the following:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">person</span> <span class="o">=</span> <span class="nn">Person</span><span class="p">::</span><span class="nf">new</span><span class="p">(</span><span class="s">"Fadi"</span><span class="nf">.to_string</span><span class="p">(),</span> <span class="s">"Hanna Al-Kass"</span><span class="nf">.to_string</span><span class="p">());</span>
<span class="nd">println!</span><span class="p">(</span><span class="s">"{}, {}"</span><span class="p">,</span> <span class="n">person</span><span class="nf">.get_last_name</span><span class="p">(),</span> <span class="n">person</span><span class="nf">.get_first_name</span><span class="p">());</span>
</code></pre></div></div>

<p>You’ve probably already looked at the code and thought to yourself “aha, <code class="language-plaintext highlighter-rouge">Person::new()</code> must be the constructor” to which you’d definitely be right. however, one thing you need to keep in mind is that Rust has no concept of a <code class="language-plaintext highlighter-rouge">constructor</code> per se. Instead, we define a static function that we use to instantiate our object. This also means <code class="language-plaintext highlighter-rouge">new</code> is not a keyword nor is it the required name of your entry point to your object; it can really be anything but <code class="language-plaintext highlighter-rouge">new</code> is the convention.</p>

<blockquote>
  <p>In short, your class constructor is a static function located inside an <code class="language-plaintext highlighter-rouge">impl</code> and turns an object of the type of the class you’re instantiating (Person in our case).</p>
</blockquote>

<h3 id="traits">Traits</h3>
<h4 id="if-this-doesnt-turn-you-into-a-rust-fanatic-i-dont-think-anything-will-sad--">If this doesn’t turn you into a Rust fanatic, I don’t think anything will. <em>Sad :-(</em></h4>

<p>A <code class="language-plaintext highlighter-rouge">trait</code> is nothing but a language feature that tells the compiler about a type-specific functionality. The definition of a <code class="language-plaintext highlighter-rouge">trait</code> may be confusing as heck to you, but it’ll all settle for you with the first example or two.</p>

<p>Remember how we were talking about classes with constructors, functions, and destructors? Well, we’ve already discussed how constructors and functions are done in Rust. Let’s talk a little about destructors. A <code class="language-plaintext highlighter-rouge">destructor</code> is a class function that invokes itself once the class is out of scope. In some low-level programming languages like C++, a class destructor is normally used to deallocate all allocated memory and preform some house cleaning. Rust has an <code class="language-plaintext highlighter-rouge">impl</code> destruction functionality (<code class="language-plaintext highlighter-rouge">trait</code>) called <code class="language-plaintext highlighter-rouge">Drop</code>. Let’s look at how this trait can be implemented and invoked:</p>

<p>Let’s say you have a <code class="language-plaintext highlighter-rouge">Response</code> object you return to a HTTP validation layer that sends it to an end-client. Once this operation is complete, you have no business in maintaining this <code class="language-plaintext highlighter-rouge">Response</code> object, so it’ll delete itself once it’s out of scope. Let’s start by defining this structure:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">struct</span> <span class="n">Response</span> <span class="p">{</span>
  <span class="n">code</span><span class="p">:</span> <span class="nb">i32</span><span class="p">,</span>
  <span class="n">message</span><span class="p">:</span> <span class="nb">String</span>
<span class="p">}</span>

<span class="k">fn</span> <span class="nf">main</span> <span class="p">()</span> <span class="p">{</span>
  <span class="k">let</span> <span class="n">res</span> <span class="o">=</span> <span class="n">Response</span> <span class="p">{</span>
    <span class="n">code</span><span class="p">:</span> <span class="mi">200</span><span class="p">,</span>
    <span class="n">message</span><span class="p">:</span> <span class="s">"OK"</span><span class="nf">.to_string</span><span class="p">()</span>
  <span class="p">};</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Now let’s add a <code class="language-plaintext highlighter-rouge">Drop</code> <code class="language-plaintext highlighter-rouge">trait</code> to our object and see when <code class="language-plaintext highlighter-rouge">Drop</code> is invoked:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">impl</span> <span class="nb">Drop</span> <span class="k">for</span> <span class="n">Response</span> <span class="p">{</span>
  <span class="k">fn</span> <span class="nf">drop</span> <span class="p">(</span><span class="o">&amp;</span><span class="k">mut</span> <span class="k">self</span><span class="p">)</span> <span class="p">{</span>
    <span class="nd">println!</span><span class="p">(</span><span class="s">"I ran out of scope. I'm about to be destroyed"</span><span class="p">)</span>
  <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<p>If you try to run the complete program now, i.e.:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">struct</span> <span class="n">Response</span> <span class="p">{</span>
  <span class="n">code</span><span class="p">:</span> <span class="nb">i32</span><span class="p">,</span>
  <span class="n">message</span><span class="p">:</span> <span class="nb">String</span>
<span class="p">}</span>

<span class="k">impl</span> <span class="nb">Drop</span> <span class="k">for</span> <span class="n">Response</span> <span class="p">{</span>
  <span class="k">fn</span> <span class="nf">drop</span> <span class="p">(</span><span class="o">&amp;</span><span class="k">mut</span> <span class="k">self</span><span class="p">)</span> <span class="p">{</span>
    <span class="nd">println!</span><span class="p">(</span><span class="s">"I ran out of scope. I'm about to be destroyed"</span><span class="p">)</span>
  <span class="p">}</span>
<span class="p">}</span>

<span class="k">fn</span> <span class="nf">main</span> <span class="p">()</span> <span class="p">{</span>
  <span class="k">let</span> <span class="n">res</span> <span class="o">=</span> <span class="n">Response</span> <span class="p">{</span>
    <span class="n">code</span><span class="p">:</span> <span class="mi">200</span><span class="p">,</span>
    <span class="n">message</span><span class="p">:</span> <span class="s">"OK"</span><span class="nf">.to_string</span><span class="p">()</span>
  <span class="p">};</span>
<span class="p">}</span>
</code></pre></div></div>

<p>You’ll see the following output right before the program finishes executing:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>I ran out of scope. I'm about to be destroyed
</code></pre></div></div>

<p>Let’s look at another example.
If you’ve ever done any scientific computation in Python, chances are you’ve overloaded some of the arithmetic operations (<code class="language-plaintext highlighter-rouge">+</code>, <code class="language-plaintext highlighter-rouge">-</code>, <code class="language-plaintext highlighter-rouge">*</code>, <code class="language-plaintext highlighter-rouge">/</code>, <code class="language-plaintext highlighter-rouge">%</code>, etc). A vector class with <code class="language-plaintext highlighter-rouge">+</code> overloaded would look something like the following:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">class</span> <span class="nc">Vector</span><span class="p">:</span>
  <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="n">self</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
    <span class="n">self</span><span class="p">.</span><span class="n">a</span> <span class="o">=</span> <span class="n">a</span>
    <span class="n">self</span><span class="p">.</span><span class="n">b</span> <span class="o">=</span> <span class="n">b</span>
  <span class="k">def</span> <span class="nf">__add__</span><span class="p">(</span><span class="n">self</span><span class="p">,</span> <span class="n">otherVector</span><span class="p">):</span>
    <span class="k">return</span> <span class="nc">Vector</span><span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="n">a</span> <span class="o">+</span> <span class="n">otherVector</span><span class="p">.</span><span class="n">a</span><span class="p">,</span> <span class="n">self</span><span class="p">.</span><span class="n">b</span> <span class="o">+</span> <span class="n">otherVector</span><span class="p">.</span><span class="n">b</span><span class="p">)</span>
  <span class="k">def</span> <span class="nf">__str__</span><span class="p">(</span><span class="n">self</span><span class="p">):</span>
    <span class="k">return</span> <span class="sh">"</span><span class="s">Vector(%s, %s)</span><span class="sh">"</span> <span class="o">%</span> <span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="n">a</span><span class="p">,</span> <span class="n">self</span><span class="p">.</span><span class="n">b</span><span class="p">)</span>
</code></pre></div></div>

<p>And if you were to add two <code class="language-plaintext highlighter-rouge">Vector</code> objects together, you’d so something like the following:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">v1</span> <span class="o">=</span> <span class="nc">Vector</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="n">v2</span> <span class="o">=</span> <span class="nc">Vector</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="mi">7</span><span class="p">)</span>
<span class="n">v3</span> <span class="o">=</span> <span class="n">v1</span> <span class="o">+</span> <span class="n">v2</span>
</code></pre></div></div>

<p>And print the result as follows:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nf">print</span><span class="p">(</span><span class="n">v3</span><span class="p">)</span>
</code></pre></div></div>

<p>This will print the following:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nc">Vector</span><span class="p">(</span><span class="mi">6</span><span class="p">,</span> <span class="mi">9</span><span class="p">)</span>
</code></pre></div></div>

<p>Hmm.. Let’s see how we could go about implementing this in Rust. First, we’d need to somehow find a way to add objects (i.e., overload the <code class="language-plaintext highlighter-rouge">+</code> operator). Second, we’d need to be able to give our object to <code class="language-plaintext highlighter-rouge">println</code> and see it print something like <code class="language-plaintext highlighter-rouge">Vector(#, #)</code>. Lucky for us, both of these features are available as <code class="language-plaintext highlighter-rouge">trait</code>s we can implement. Let’s chase them one at a time. We’ll start with the <code class="language-plaintext highlighter-rouge">Add</code> <code class="language-plaintext highlighter-rouge">trait</code>.</p>

<p>Here’s our Rust <code class="language-plaintext highlighter-rouge">Vector</code> object:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">struct</span> <span class="n">Vector</span> <span class="p">{</span>
  <span class="n">a</span><span class="p">:</span> <span class="nb">i32</span><span class="p">,</span>
  <span class="n">b</span><span class="p">:</span> <span class="nb">i32</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Then we add the <code class="language-plaintext highlighter-rouge">constructor</code>:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">impl</span> <span class="n">Vector</span> <span class="p">{</span>
    <span class="k">fn</span> <span class="nf">new</span> <span class="p">(</span><span class="n">a</span><span class="p">:</span> <span class="nb">i32</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="nb">i32</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="n">Vector</span> <span class="p">{</span>
        <span class="k">return</span> <span class="n">Vector</span> <span class="p">{</span>
            <span class="n">a</span><span class="p">:</span> <span class="n">a</span><span class="p">,</span>
            <span class="n">b</span><span class="p">:</span> <span class="n">b</span>
        <span class="p">};</span>
    <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<p>We, then, add the <code class="language-plaintext highlighter-rouge">+</code> operation overloaded to our <code class="language-plaintext highlighter-rouge">Vector</code> <code class="language-plaintext highlighter-rouge">struct</code> as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">use</span> <span class="nn">std</span><span class="p">::</span><span class="nn">ops</span><span class="p">::</span><span class="nb">Add</span><span class="p">;</span>

<span class="k">impl</span> <span class="nb">Add</span> <span class="k">for</span> <span class="n">Vector</span> <span class="p">{</span>
  <span class="k">type</span> <span class="n">Output</span> <span class="o">=</span> <span class="n">Vector</span><span class="p">;</span>
  <span class="k">fn</span> <span class="nf">add</span> <span class="p">(</span><span class="k">self</span><span class="p">,</span> <span class="n">other_vector</span><span class="p">:</span> <span class="n">Vector</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="n">Vector</span> <span class="p">{</span>
    <span class="k">return</span> <span class="n">Vector</span> <span class="p">{</span>
      <span class="n">a</span><span class="p">:</span> <span class="k">self</span><span class="py">.a</span> <span class="o">+</span> <span class="n">other_vector</span><span class="py">.a</span><span class="p">,</span>
      <span class="n">b</span><span class="p">:</span> <span class="k">self</span><span class="py">.b</span> <span class="o">+</span> <span class="n">other_vector</span><span class="py">.b</span>
    <span class="p">};</span>
  <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<p>At this point, we can have the following in our <code class="language-plaintext highlighter-rouge">main</code> function:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">v1</span> <span class="o">=</span> <span class="nn">Vector</span><span class="p">::</span><span class="nf">new</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">);</span>
<span class="k">let</span> <span class="n">v2</span> <span class="o">=</span> <span class="nn">Vector</span><span class="p">::</span><span class="nf">new</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="mi">7</span><span class="p">);</span>
<span class="k">let</span> <span class="n">v3</span> <span class="o">=</span> <span class="n">v1</span> <span class="o">+</span> <span class="n">v2</span><span class="p">;</span>
</code></pre></div></div>

<p>But we can’t print quite yet. Let’s implement this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">use</span> <span class="nn">std</span><span class="p">::</span><span class="nn">fmt</span><span class="p">::{</span><span class="n">Debug</span><span class="p">,</span> <span class="n">Formatter</span><span class="p">,</span> <span class="nb">Result</span><span class="p">};</span>
<span class="k">impl</span> <span class="n">Debug</span> <span class="k">for</span> <span class="n">Vector</span> <span class="p">{</span>
  <span class="k">fn</span> <span class="nf">fmt</span><span class="p">(</span><span class="o">&amp;</span><span class="k">self</span><span class="p">,</span> <span class="n">f</span><span class="p">:</span> <span class="o">&amp;</span><span class="k">mut</span> <span class="n">Formatter</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">Result</span> <span class="p">{</span>
    <span class="k">return</span> <span class="nd">write!</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="s">"Vector({}, {})"</span><span class="p">,</span> <span class="k">self</span><span class="py">.a</span><span class="p">,</span> <span class="k">self</span><span class="py">.b</span><span class="p">);</span>
  <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Now we can print <code class="language-plaintext highlighter-rouge">v3</code> as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nd">println!</span><span class="p">(</span><span class="s">"{:?}"</span><span class="p">,</span> <span class="n">v3</span><span class="p">);</span>
</code></pre></div></div>

<p>And get the following output:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nf">Vector</span><span class="p">(</span><span class="mi">6</span><span class="p">,</span> <span class="mi">9</span><span class="p">)</span>
</code></pre></div></div>

<p>Your final program should look like the following:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">struct</span> <span class="n">Vector</span> <span class="p">{</span>
  <span class="n">a</span><span class="p">:</span> <span class="nb">i32</span><span class="p">,</span>
  <span class="n">b</span><span class="p">:</span> <span class="nb">i32</span>
<span class="p">}</span>

<span class="k">impl</span> <span class="n">Vector</span> <span class="p">{</span>
    <span class="k">fn</span> <span class="nf">new</span> <span class="p">(</span><span class="n">a</span><span class="p">:</span> <span class="nb">i32</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="nb">i32</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="n">Vector</span> <span class="p">{</span>
        <span class="k">return</span> <span class="n">Vector</span> <span class="p">{</span>
            <span class="n">a</span><span class="p">:</span> <span class="n">a</span><span class="p">,</span>
            <span class="n">b</span><span class="p">:</span> <span class="n">b</span>
        <span class="p">};</span>
    <span class="p">}</span>
<span class="p">}</span>

<span class="k">use</span> <span class="nn">std</span><span class="p">::</span><span class="nn">ops</span><span class="p">::</span><span class="nb">Add</span><span class="p">;</span>
<span class="k">impl</span> <span class="nb">Add</span> <span class="k">for</span> <span class="n">Vector</span> <span class="p">{</span>
  <span class="k">type</span> <span class="n">Output</span> <span class="o">=</span> <span class="n">Vector</span><span class="p">;</span>
  <span class="k">fn</span> <span class="nf">add</span> <span class="p">(</span><span class="k">self</span><span class="p">,</span> <span class="n">other_vector</span><span class="p">:</span> <span class="n">Vector</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="n">Vector</span> <span class="p">{</span>
    <span class="k">return</span> <span class="n">Vector</span> <span class="p">{</span>
      <span class="n">a</span><span class="p">:</span> <span class="k">self</span><span class="py">.a</span> <span class="o">+</span> <span class="n">other_vector</span><span class="py">.a</span><span class="p">,</span>
      <span class="n">b</span><span class="p">:</span> <span class="k">self</span><span class="py">.b</span> <span class="o">+</span> <span class="n">other_vector</span><span class="py">.b</span>
    <span class="p">};</span>
  <span class="p">}</span>
<span class="p">}</span>

<span class="k">use</span> <span class="nn">std</span><span class="p">::</span><span class="nn">fmt</span><span class="p">::{</span><span class="n">Debug</span><span class="p">,</span> <span class="n">Formatter</span><span class="p">,</span> <span class="nb">Result</span><span class="p">};</span>
<span class="k">impl</span> <span class="n">Debug</span> <span class="k">for</span> <span class="n">Vector</span> <span class="p">{</span>
  <span class="k">fn</span> <span class="nf">fmt</span><span class="p">(</span><span class="o">&amp;</span><span class="k">self</span><span class="p">,</span> <span class="n">f</span><span class="p">:</span> <span class="o">&amp;</span><span class="k">mut</span> <span class="n">Formatter</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">Result</span> <span class="p">{</span>
    <span class="k">return</span> <span class="nd">write!</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="s">"Vector({}, {})"</span><span class="p">,</span> <span class="k">self</span><span class="py">.a</span><span class="p">,</span> <span class="k">self</span><span class="py">.b</span><span class="p">);</span>
  <span class="p">}</span>
<span class="p">}</span>

<span class="k">fn</span> <span class="nf">main</span> <span class="p">()</span> <span class="p">{</span>
  <span class="k">let</span> <span class="n">v1</span> <span class="o">=</span> <span class="nn">Vector</span><span class="p">::</span><span class="nf">new</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">);</span>
  <span class="k">let</span> <span class="n">v2</span> <span class="o">=</span> <span class="nn">Vector</span><span class="p">::</span><span class="nf">new</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="mi">7</span><span class="p">);</span>
  <span class="k">let</span> <span class="n">v3</span> <span class="o">=</span> <span class="n">v1</span> <span class="o">+</span> <span class="n">v2</span><span class="p">;</span>
  <span class="nd">println!</span><span class="p">(</span><span class="s">"{:?}"</span><span class="p">,</span> <span class="n">v3</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Oh, and you know how I said <code class="language-plaintext highlighter-rouge">{}</code> is used to communicate output to the user while <code class="language-plaintext highlighter-rouge">{:?}</code> is usually used for debugging purposes? Well, it turns out you can overload the <code class="language-plaintext highlighter-rouge">Display</code> trail (available under <code class="language-plaintext highlighter-rouge">std::fmt</code> as well) to print your object using <code class="language-plaintext highlighter-rouge">{}</code> instead of <code class="language-plaintext highlighter-rouge">{:?}</code>.</p>

<p>So, simply replace:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">use</span> <span class="nn">std</span><span class="p">::</span><span class="nn">fmt</span><span class="p">::{</span><span class="n">Debug</span><span class="p">,</span> <span class="n">Formatter</span><span class="p">,</span> <span class="nb">Result</span><span class="p">};</span>
</code></pre></div></div>

<p>With:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">use</span> <span class="nn">std</span><span class="p">::</span><span class="nn">fmt</span><span class="p">::{</span><span class="n">Display</span><span class="p">,</span> <span class="n">Formatter</span><span class="p">,</span> <span class="nb">Result</span><span class="p">};</span>
</code></pre></div></div>

<p>And:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">impl</span> <span class="n">Debug</span> <span class="k">for</span> <span class="n">Vector</span> <span class="p">{</span>
</code></pre></div></div>

<p>With:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">impl</span> <span class="n">Display</span> <span class="k">for</span> <span class="n">Vector</span> <span class="p">{</span>
</code></pre></div></div>

<p>And:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nd">println!</span><span class="p">(</span><span class="s">"{:?}"</span><span class="p">,</span> <span class="n">v3</span><span class="p">);</span>
</code></pre></div></div>

<p>With:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nd">println!</span><span class="p">(</span><span class="s">"{}"</span><span class="p">,</span> <span class="n">v3</span><span class="p">);</span>
</code></pre></div></div>

<p>And voila, you’re all set.</p>

<h3 id="statements-vs-expressions">Statements vs. Expressions?</h3>
<p>At this point, I’m a bit tired of having to included unnecessary keywords in my code snippets, so I thought I’d introduce the concept of statement-vs-expression in Rust.</p>

<p>So, basically statements that don’t end with a semi-colon (<code class="language-plaintext highlighter-rouge">;</code>) return something and they even have a special label: <code class="language-plaintext highlighter-rouge">expressions</code>. Without getting into too much detail and get you all confused, let me instead throw a little snippet at you and let you sort it out in your head.</p>

<p>So, let’s say you have a function that takes two <code class="language-plaintext highlighter-rouge">i32</code> arguments and returns the sum of the two values. You could have your function written like this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">sum</span> <span class="p">(</span><span class="n">a</span><span class="p">:</span> <span class="nb">i32</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="nb">i32</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">i32</span> <span class="p">{</span>
  <span class="k">return</span> <span class="n">a</span> <span class="o">+</span> <span class="n">b</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p>or you could have the shorthand notation of the function by using an expression instead of a statement:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">sum</span> <span class="p">(</span><span class="n">a</span><span class="p">:</span> <span class="nb">i32</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="nb">i32</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">i32</span> <span class="p">{</span>
  <span class="n">a</span> <span class="o">+</span> <span class="n">b</span>
<span class="p">}</span>
</code></pre></div></div>

<p>From this point on, I will be using expressions whenever possible.</p>

<h3 id="our-journey-into-the-specifics">Our Journey into the Specifics</h3>
<p>We’re now going to dive into the basics of Rust.</p>

<h4 id="variableobject-declaration">Variable/Object Declaration</h4>
<p>We’ve been declaring objects and variables all over the place already, but perhaps there’s more to them than what’s been covered already. If you want to declare an integer <code class="language-plaintext highlighter-rouge">x</code> and assign the value <code class="language-plaintext highlighter-rouge">2</code> to it, you could do so as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">x</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
</code></pre></div></div>

<p>But if you were to write an operating system, a kernel module, and/or an application that runs on an embedded system, the size of your object really matters, and chances are you’ll need to control these sizes. Unless you dive into the specifics of the design of the compiler of Rust, you really have no idea how many bits are used to store your variable. There must be a better way to carry this out, and here’s how. Rust allows you to specify the type of your object with a slight edit to your statement. Instead of writing your variable declaration like this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">x</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
</code></pre></div></div>

<p>You could write it like this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">x</span><span class="p">:</span> <span class="nb">i8</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
</code></pre></div></div>

<p>And you know for sure that your variable is stored as an 8-bit integer.</p>

<p>Read more about Primitive Types and Object Declaration <a href="https://doc.Rust-lang.org/book/primitive-types.html">here</a></p>

<h4 id="mutability">Mutability</h4>
<p>By default, objects and variables in Rust are immutable (not modifiable after they’ve been declared). Something like the following won’t work:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">x</span><span class="p">:</span> <span class="nb">i8</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
<span class="n">x</span> <span class="o">=</span> <span class="mi">3</span><span class="p">;</span>
</code></pre></div></div>

<p>To be able to change the value of <code class="language-plaintext highlighter-rouge">x</code>, we need to tell the compiler to mark our variable as mutable (able to change value after it’s been declared). This introduces a slight change to our declaration that’s pretty intuitive; you simply add the keyword <code class="language-plaintext highlighter-rouge">mut</code> on the left side of your object declaration statement like this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="k">mut</span> <span class="n">x</span><span class="p">:</span> <span class="nb">i8</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
</code></pre></div></div>

<p>And now the following will work like a charm!</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">x</span> <span class="o">=</span> <span class="mi">3</span><span class="p">;</span>
</code></pre></div></div>

<h4 id="type-aliases">Type Aliases</h4>
<p>Rust has a keyword called <code class="language-plaintext highlighter-rouge">type</code> used to declare aliases of other types.
Say you want to use <code class="language-plaintext highlighter-rouge">i32</code> across a whole <code class="language-plaintext highlighter-rouge">class</code>, <code class="language-plaintext highlighter-rouge">module</code> or even across your whole application, and for clarity’s sake you’d rather use <code class="language-plaintext highlighter-rouge">Int</code> instead of <code class="language-plaintext highlighter-rouge">i32</code> to reference 32-bit integers. You could define your <code class="language-plaintext highlighter-rouge">Int</code> type as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">type</span> <span class="n">Int</span> <span class="o">=</span> <span class="nb">i32</span><span class="p">;</span>
</code></pre></div></div>

<p>And now to use your new type, you could define your variables like this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">var1</span><span class="p">:</span> <span class="n">Int</span> <span class="o">=</span> <span class="mi">10</span><span class="p">;</span>
<span class="k">let</span> <span class="n">var2</span><span class="p">:</span> <span class="n">Int</span> <span class="o">=</span> <span class="mi">20</span><span class="p">;</span>
</code></pre></div></div>

<p>And so on.</p>

<h4 id="functions">Functions</h4>
<p>Function declarations are pretty intuitive and straightforward. Say you want to write a <code class="language-plaintext highlighter-rouge">greeting</code> function that prints out the test <code class="language-plaintext highlighter-rouge">"hello there!"</code> over <code class="language-plaintext highlighter-rouge">stdio</code>. You’d write your function as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">greeting</span> <span class="p">()</span> <span class="p">{</span>
    <span class="nd">println!</span><span class="p">(</span><span class="s">"hello there!"</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div></div>

<p>What if you want to pass the string to the function instead of hard-coding a specific value? Then, you’d write it like this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">greeting</span> <span class="p">(</span><span class="n">message</span><span class="p">:</span> <span class="nb">String</span><span class="p">)</span> <span class="p">{</span>
    <span class="c1">// TODO: Implement me</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Multiple function arguments? Sure! Here’s how:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">greeting</span> <span class="p">(</span><span class="n">name</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span> <span class="n">message</span><span class="p">:</span> <span class="nb">String</span><span class="p">)</span> <span class="p">{</span>
    <span class="c1">// TODO: Implement me</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Functions with return values? Here’s how:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">add</span> <span class="p">(</span><span class="n">a</span><span class="p">:</span> <span class="nb">i32</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="nb">i32</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">i32</span> <span class="p">{</span>
 <span class="n">a</span> <span class="o">+</span> <span class="n">b</span>
<span class="p">}</span>
</code></pre></div></div>

<blockquote>
  <p>i32 is a 32-bit integer type in Rust. You can read more about Rust’s support for numeric types <a href="https://doc.Rust-lang.org/book/primitive-types.html#numeric-types">here</a>.</p>
</blockquote>

<p>Remember that we’re using an <code class="language-plaintext highlighter-rouge">expression</code> in the code snippet above. If you wanted to replace it with a statement <code class="language-plaintext highlighter-rouge">return a + b;</code> will do.</p>

<h4 id="closures">Closures</h4>
<p>The easiest definition of a <code class="language-plaintext highlighter-rouge">closure</code> I can give is that a <code class="language-plaintext highlighter-rouge">closure</code> is a function with untyped arguments. If you were to write a function that multiplies two numbers together and return the product, you’d do so as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">mul</span> <span class="p">(</span><span class="n">a</span><span class="p">:</span> <span class="nb">i32</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="nb">i32</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">i32</span> <span class="p">{</span>
	<span class="n">a</span> <span class="o">*</span> <span class="n">b</span>
<span class="p">}</span>
</code></pre></div></div>

<p>This function can be written as a closure as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">mul</span> <span class="o">=</span> <span class="p">|</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">|</span> <span class="n">a</span> <span class="o">*</span> <span class="n">b</span><span class="p">;</span>
</code></pre></div></div>

<p>And then you can call it the exact same way you’d call a function, i.e.:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>println!("{}", mul(10, 20));
</code></pre></div></div>

<p>If you, for whatever reason, want to strongly-type your closure arguments, you can do so by defining their types the same way you’d define function arguments, e.g.:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">mul</span> <span class="o">=</span> <span class="p">|</span><span class="n">a</span><span class="p">:</span> <span class="nb">i32</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="nb">i32</span><span class="p">|</span> <span class="n">a</span> <span class="o">*</span> <span class="n">b</span><span class="p">;</span>
</code></pre></div></div>

<p>And you can even strongly-type your closure return type as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">mul</span> <span class="o">=</span> <span class="p">|</span><span class="n">a</span><span class="p">:</span> <span class="nb">i32</span><span class="p">,</span> <span class="n">b</span><span class="p">:</span> <span class="nb">i32</span><span class="p">|</span> <span class="k">-&gt;</span> <span class="nb">i32</span> <span class="p">{</span><span class="n">a</span> <span class="o">*</span> <span class="n">b</span><span class="p">};</span>
</code></pre></div></div>

<p>But that’ll require you to wrap your closure content within two curly brackets (<code class="language-plaintext highlighter-rouge">{</code> and <code class="language-plaintext highlighter-rouge">}</code>).</p>

<p>You can read more about most of the cool stuff you can do with <code class="language-plaintext highlighter-rouge">closure</code>s <a href="https://doc.Rust-lang.org/book/closures.html">here</a>.</p>

<h4 id="function-pointers">Function Pointers</h4>
<p>If you’re coming from a solid background in languages like C and C++, chances are you’ve worked with function pointers a lot. You’ve probably even worked with function pointers in languages like JavaScript and Python without ever coming across the name.
At its core, a function pointer is a variable holding access to a specific memory location representing the beginning of the function. In JavaScript, if you were to have the following:</p>

<div class="language-js highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="kd">function</span> <span class="nf">callee</span> <span class="p">()</span> <span class="p">{</span>
  <span class="c1">// TODO: Implement me</span>
<span class="p">}</span>

<span class="kd">function</span> <span class="nf">caller</span> <span class="p">(</span><span class="nx">callback</span><span class="p">)</span> <span class="p">{</span>
  <span class="c1">// TODO: Implement a task</span>
  <span class="nf">callback</span><span class="p">();</span>
<span class="p">}</span>

<span class="nf">caller</span><span class="p">(</span><span class="nx">callback</span><span class="p">);</span>
</code></pre></div></div>

<p>It can be said that “<code class="language-plaintext highlighter-rouge">caller</code> is a function that takes an argument of type function pointer (which in this case is our <code class="language-plaintext highlighter-rouge">callee</code> function)”.</p>

<p>Rust isn’t that flexible when it comes to function pointers though. If you were to pass a function pointer to a function, the calling function needs to have a somewhat hard set on callback function specifications; your calling function needs to specify the arguments and the return type of the callee function. Let’s discuss a use case where you may want to use a function pointer.</p>

<p>Say you’re creating a struct called <code class="language-plaintext highlighter-rouge">CommandInterface</code> that will contain two fields: (1) a command string, and (2) a function pointer pointing to the function to be executed with the specified command. Let’s start by defining the outer skeleton of our interface <code class="language-plaintext highlighter-rouge">struct</code>:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">struct</span> <span class="n">CommandInterface</span> <span class="p">{</span>
	<span class="nb">str</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span>
	<span class="n">exec</span><span class="p">:</span> <span class="k">fn</span><span class="p">()</span> <span class="k">-&gt;</span> <span class="nb">i8</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Here we’re telling the compiler to expect our function pointer to have no arguments and return an 8-bit integer. Let’s now define a function according to these specifications:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">ls</span> <span class="p">()</span> <span class="k">-&gt;</span> <span class="nb">i8</span> <span class="p">{</span>
	<span class="c1">// TODO: Implement me</span>
	<span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<blockquote>
  <p>Our function needs not have a specific name. I’m only naming it after the command you’re about to see below to maintain a convention.</p>
</blockquote>

<p>Let’s now define our function, set the function pointer, and see how we could use the function pointer in calling our function.</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">cmd</span> <span class="o">=</span> <span class="n">CommandInterface</span> <span class="p">{</span>
	<span class="nb">str</span><span class="p">:</span> <span class="s">"ls"</span><span class="nf">.to_string</span><span class="p">(),</span>
	<span class="n">exec</span><span class="p">:</span> <span class="n">ls</span> <span class="c1">// points to the ls function declared above</span>
<span class="p">};</span>

<span class="p">(</span><span class="n">cmd</span><span class="py">.exec</span><span class="p">)();</span>
</code></pre></div></div>

<blockquote>
  <p>The parenthesis (<code class="language-plaintext highlighter-rouge">()</code>) around <code class="language-plaintext highlighter-rouge">cmd.exec</code> are a syntax requirement. If you forget to add them, the compiler will throw an error at you.</p>
</blockquote>

<p>But what about functions with arguments? Say we want to pass some command arguments to our function, how would we do that? Well, this is pretty easy and it’ll require very slight changes. You could replace:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">exec</span><span class="p">:</span> <span class="k">fn</span><span class="p">()</span> <span class="k">-&gt;</span> <span class="nb">i8</span>
</code></pre></div></div>

<p>with:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">exec</span><span class="p">:</span> <span class="k">fn</span><span class="p">(</span><span class="n">arg1</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span> <span class="n">arg2</span><span class="p">:</span> <span class="nb">String</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">i8</span>
</code></pre></div></div>

<p>and:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">fn</span> <span class="nf">ls</span> <span class="p">(</span><span class="n">arg1</span><span class="p">:</span> <span class="nb">String</span><span class="p">,</span> <span class="n">arg2</span><span class="p">:</span> <span class="nb">String</span><span class="p">)</span> <span class="k">-&gt;</span> <span class="nb">i8</span>
</code></pre></div></div>

<p>with:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="p">(</span><span class="n">cmd</span><span class="py">.exec</span><span class="p">)();</span>
</code></pre></div></div>

<p>with something like this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="p">(</span><span class="n">cmd</span><span class="py">.exec</span><span class="p">)(</span><span class="s">"-a"</span><span class="nf">.to_string</span><span class="p">(),</span> <span class="s">"-l"</span><span class="nf">.to_string</span><span class="p">());</span>
</code></pre></div></div>

<blockquote>
  <p>In a practical world, it’d be better to pass a vector of arguments but I intentionally ignored vectors just to keep things clean.</p>
</blockquote>

<h4 id="conditionals">Conditionals</h4>
<p>When it comes to code path redirection, Rust has the three keywords you’ll likely find in most programming languages out there: <code class="language-plaintext highlighter-rouge">if</code>, <code class="language-plaintext highlighter-rouge">else</code>, and <code class="language-plaintext highlighter-rouge">else if</code>. If you’ve worked with languages like <code class="language-plaintext highlighter-rouge">C</code>, <code class="language-plaintext highlighter-rouge">C++</code>, <code class="language-plaintext highlighter-rouge">C#</code>, <code class="language-plaintext highlighter-rouge">Java</code>, and <code class="language-plaintext highlighter-rouge">JavaScript</code>, then you already know how to work with conditional expressions in Rust. Here’s the trick: conditional expressions in Rust are done exactly the way they’re done in the languages I just mentioned, except without the wrapping parenthesis, e.g.:</p>

<p>The following JavaScript code:</p>

<div class="language-js highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">if </span><span class="p">(</span><span class="nx">x</span> <span class="o">==</span> <span class="mi">0</span> <span class="o">||</span> <span class="nx">x</span> <span class="o">==</span> <span class="mi">2</span><span class="p">)</span> <span class="p">{</span>
	<span class="c1">// TODO: Implement me</span>
<span class="p">}</span>
<span class="k">else</span> <span class="k">if </span><span class="p">(</span><span class="nx">x</span> <span class="o">==</span> <span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
	<span class="c1">// TODO: Implement me</span>
<span class="p">}</span>
<span class="k">else</span> <span class="p">{</span>
	<span class="c1">// TODO: Implement me</span>
<span class="p">}</span>
</code></pre></div></div>

<p>is written in Rust as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">if</span> <span class="n">x</span> <span class="o">==</span> <span class="mi">0</span> <span class="p">||</span> <span class="n">x</span> <span class="o">==</span> <span class="mi">2</span> <span class="p">{</span>
	<span class="c1">// TODO: Implement me</span>
<span class="p">}</span>
<span class="k">else</span> <span class="k">if</span> <span class="n">x</span> <span class="o">==</span> <span class="mi">1</span> <span class="p">{</span>
	<span class="c1">// TODO: Implement me</span>
<span class="p">}</span>
<span class="k">else</span> <span class="p">{</span>
	<span class="c1">// TODO: Implement me</span>
<span class="p">}</span>
</code></pre></div></div>

<p>And that’s really all there is to it when it comes to code path redirection.</p>

<p>You might, however, be used to using the <code class="language-plaintext highlighter-rouge">?</code> operator for quick things like “if <code class="language-plaintext highlighter-rouge">x</code> is even do this and if <code class="language-plaintext highlighter-rouge">x</code> is odd do that”, e.g.:</p>

<div class="language-js highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="c1">// The following JavaScript statement sets `res` to 'even' if `x` is an even value, and 'odd' if `x` is an odd value</span>

<span class="kd">var</span> <span class="nx">res</span> <span class="o">=</span> <span class="nx">x</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span> <span class="p">?</span> <span class="dl">'</span><span class="s1">even</span><span class="dl">'</span> <span class="p">:</span> <span class="dl">'</span><span class="s1">odd</span><span class="dl">'</span><span class="p">;</span>
</code></pre></div></div>

<p>In Rust, the same can be written as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">res</span> <span class="o">=</span> <span class="k">if</span> <span class="n">x</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span> <span class="p">{</span><span class="s">"even"</span><span class="p">}</span> <span class="k">else</span> <span class="p">{</span><span class="s">"odd"</span><span class="p">};</span>
</code></pre></div></div>

<h4 id="matching-aka-pseudo-switch-case-statements">Matching (aka pseudo-Switch-Case Statements)</h4>
<p>Matching is your typical <code class="language-plaintext highlighter-rouge">switch</code> case code block plus the ability to return something. If you were to compare integer <code class="language-plaintext highlighter-rouge">x</code> against a number of different values, using classical <code class="language-plaintext highlighter-rouge">if - else -- else if</code> gets pretty tedious really quickly, so developers tend to resort to <code class="language-plaintext highlighter-rouge">switch</code> case statements. Referring back to our <code class="language-plaintext highlighter-rouge">x</code> example, the following JavaScript compares <code class="language-plaintext highlighter-rouge">x</code> against 5 different values (cases):</p>

<div class="language-js highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">switch </span><span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span>
  <span class="k">case</span> <span class="mi">1</span><span class="p">:</span>
    <span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="dl">'</span><span class="s1">x is 1</span><span class="dl">'</span><span class="p">);</span>
    <span class="k">break</span><span class="p">;</span>
  <span class="k">case</span> <span class="mi">2</span><span class="p">:</span>
    <span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="dl">'</span><span class="s1">x is 2</span><span class="dl">'</span><span class="p">);</span>
    <span class="k">break</span><span class="p">;</span>
  <span class="k">case</span> <span class="mi">3</span><span class="p">:</span>
    <span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="dl">'</span><span class="s1">x is 3</span><span class="dl">'</span><span class="p">);</span>
    <span class="k">break</span><span class="p">;</span>
  <span class="k">case</span> <span class="mi">4</span><span class="p">:</span>
    <span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="dl">'</span><span class="s1">x is 4</span><span class="dl">'</span><span class="p">);</span>
    <span class="k">break</span><span class="p">;</span>
  <span class="nl">default</span><span class="p">:</span>
    <span class="nx">console</span><span class="p">.</span><span class="nf">log</span><span class="p">(</span><span class="dl">'</span><span class="s1">x is something else</span><span class="dl">'</span><span class="p">);</span>
    <span class="k">break</span><span class="p">;</span>
<span class="p">}</span>
</code></pre></div></div>

<p>The snipper above can be written in Rust as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">match</span> <span class="n">x</span> <span class="p">{</span>
    <span class="mi">1</span> <span class="k">=&gt;</span> <span class="nd">println!</span><span class="p">(</span><span class="s">"x is 1"</span><span class="p">),</span>
    <span class="mi">2</span> <span class="k">=&gt;</span> <span class="nd">println!</span><span class="p">(</span><span class="s">"x is 2"</span><span class="p">),</span>
    <span class="mi">3</span> <span class="k">=&gt;</span> <span class="nd">println!</span><span class="p">(</span><span class="s">"x is 3"</span><span class="p">),</span>
    <span class="mi">4</span> <span class="k">=&gt;</span> <span class="nd">println!</span><span class="p">(</span><span class="s">"x is 4"</span><span class="p">),</span>
    <span class="mi">5</span> <span class="k">=&gt;</span> <span class="nd">println!</span><span class="p">(</span><span class="s">"x is 5"</span><span class="p">),</span>
    <span class="n">_</span> <span class="k">=&gt;</span> <span class="nd">println!</span><span class="p">(</span><span class="s">"x is something else"</span><span class="p">)</span>
  <span class="p">};</span>
</code></pre></div></div>

<blockquote>
  <p>_ is how you handle <code class="language-plaintext highlighter-rouge">default</code> cases</p>
</blockquote>

<p>But things don’t end here; there’s more to <code class="language-plaintext highlighter-rouge">match</code> statements. Like I mentioned above, you can actually return a value or an object from a <code class="language-plaintext highlighter-rouge">match</code> statement. Let’s do some refactoring to our code snippet above and make it return the actual string instead of printing it to screen:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">res</span> <span class="o">=</span> <span class="k">match</span> <span class="n">x</span> <span class="p">{</span>
    <span class="mi">1</span> <span class="k">=&gt;</span> <span class="s">"x is 1"</span><span class="p">,</span>
    <span class="mi">2</span> <span class="k">=&gt;</span> <span class="s">"x is 2"</span><span class="p">,</span>
    <span class="mi">3</span> <span class="k">=&gt;</span> <span class="s">"x is 3"</span><span class="p">,</span>
    <span class="mi">4</span> <span class="k">=&gt;</span> <span class="s">"x is 4"</span><span class="p">,</span>
    <span class="mi">5</span> <span class="k">=&gt;</span> <span class="s">"x is 5"</span><span class="p">,</span>
    <span class="n">_</span> <span class="k">=&gt;</span> <span class="s">"x is something else"</span>
  <span class="p">};</span>
  <span class="nd">println!</span><span class="p">(</span><span class="s">"{}"</span><span class="p">,</span> <span class="n">res</span><span class="p">);</span>
</code></pre></div></div>

<p>That will print the exact same thing except it handed you back the string instead of printing it, and you printed it.</p>

<p><code class="language-plaintext highlighter-rouge">match</code> can work with sophisticated objects and patterns. Read more about it <a href="https://doc.rust-lang.org/book/match.html">here</a>.</p>

<h4 id="loops">Loops</h4>
<p>Loops are a very interesting subject in Rust. The language currently has three approaches to any kind of iterative activity. These three approaches use three separate keywords: <code class="language-plaintext highlighter-rouge">for</code>, <code class="language-plaintext highlighter-rouge">while</code>, and <code class="language-plaintext highlighter-rouge">loop</code>.</p>

<p>The <code class="language-plaintext highlighter-rouge">for</code> loop is used when you’ve already decided the number of times you’d like to iterate. For example, the following will loop 9 times and print the values <code class="language-plaintext highlighter-rouge">0</code> through <code class="language-plaintext highlighter-rouge">9</code>:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">for</span> <span class="n">i</span> <span class="k">in</span> <span class="mi">0</span><span class="o">..</span><span class="mi">10</span> <span class="p">{</span>
    <span class="nd">println!</span><span class="p">(</span><span class="s">"{}"</span><span class="p">,</span> <span class="n">i</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div></div>

<p>This interprets to the following Python code:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nf">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">10</span><span class="p">):</span>
    <span class="nf">print</span><span class="p">(</span><span class="sh">"</span><span class="s">%d</span><span class="sh">"</span> <span class="o">%</span> <span class="n">i</span><span class="p">)</span>
</code></pre></div></div>

<p>You can also iterate over a list using a <code class="language-plaintext highlighter-rouge">for</code> loop as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">for</span> <span class="n">i</span> <span class="k">in</span> <span class="o">&amp;</span><span class="p">[</span><span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">30</span><span class="p">]</span> <span class="p">{</span>
    <span class="nd">println!</span><span class="p">(</span><span class="s">"{}"</span><span class="p">,</span> <span class="n">i</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div></div>

<p>This is equivalent to the following Python code:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="p">[</span><span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="mi">30</span><span class="p">]:</span>
    <span class="nf">print</span><span class="p">(</span><span class="sh">"</span><span class="s">%d</span><span class="sh">"</span> <span class="o">%</span> <span class="n">i</span><span class="p">)</span>
</code></pre></div></div>

<p><code class="language-plaintext highlighter-rouge">for</code> loops can also preform some sophisticated tasks. For instance, if you have the string <code class="language-plaintext highlighter-rouge">"hello\nworld\nmy\nname\nis\nFadi"</code> and you want it up split it up using the linefeed (<code class="language-plaintext highlighter-rouge">\n</code>) delimiter, you can use the <code class="language-plaintext highlighter-rouge">lines()</code> function. This function returns an enumerator containing both the substring and the line number. So something like the following:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">my_str_tokens</span> <span class="o">=</span> <span class="s">"hello</span><span class="se">\n</span><span class="s">world</span><span class="se">\n</span><span class="s">my</span><span class="se">\n</span><span class="s">name</span><span class="se">\n</span><span class="s">is</span><span class="se">\n</span><span class="s">Fadi"</span><span class="nf">.lines</span><span class="p">();</span>
<span class="k">for</span> <span class="p">(</span><span class="n">line_no</span><span class="p">,</span> <span class="n">term</span><span class="p">)</span> <span class="k">in</span> <span class="n">my_str_tokens</span><span class="nf">.enumerate</span><span class="p">()</span> <span class="p">{</span>
    <span class="nd">println!</span><span class="p">(</span><span class="s">"{}: {}"</span><span class="p">,</span> <span class="n">line_no</span><span class="p">,</span> <span class="n">term</span><span class="p">);</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Results in this:</p>

<div class="language-plaintext highlighter-rouge"><div class="highlight"><pre class="highlight"><code>0: hello
1: world
2: my
3: name
4: is
5: Fadi
</code></pre></div></div>

<p>The above example is equivalent to the following Python code:</p>

<div class="language-python highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">myStrTokens</span> <span class="o">=</span> <span class="sh">"</span><span class="s">hello</span><span class="se">\n</span><span class="s">world</span><span class="se">\n</span><span class="s">my</span><span class="se">\n</span><span class="s">name</span><span class="se">\n</span><span class="s">is</span><span class="se">\n</span><span class="s">Fadi</span><span class="sh">"</span><span class="p">.</span><span class="nf">split</span><span class="p">(</span><span class="sh">"</span><span class="se">\n</span><span class="sh">"</span><span class="p">)</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nf">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nf">len</span><span class="p">(</span><span class="n">myStrTokens</span><span class="p">)):</span>
    <span class="nf">print</span><span class="p">(</span><span class="sh">"</span><span class="s">%d: %s</span><span class="sh">"</span> <span class="o">%</span> <span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">myStrTokens</span><span class="p">[</span><span class="n">i</span><span class="p">]))</span>
</code></pre></div></div>

<p>The <code class="language-plaintext highlighter-rouge">while</code> loop is used when you’re not sure how many times you need to loop. It works the exact same way a <code class="language-plaintext highlighter-rouge">while</code> loop works in languages like C, C++, C#, Java, JavaScript, and Python. Here’s a JavaScript example:</p>

<div class="language-js highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nx">bool</span> <span class="nx">status</span> <span class="o">=</span> <span class="kc">true</span><span class="p">;</span>
<span class="k">while </span><span class="p">(</span><span class="nx">status</span><span class="p">)</span> <span class="p">{</span>
  <span class="c1">// add some case that can set `status` to false</span>
<span class="p">}</span>
</code></pre></div></div>

<p>The snippet above can be translated into Rust and look like the following:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">status</span><span class="p">:</span> <span class="nb">bool</span> <span class="o">=</span> <span class="k">true</span><span class="p">;</span>
<span class="k">while</span> <span class="n">status</span> <span class="p">{</span>
  <span class="c1">// add some case that can set `status` to false</span>
<span class="p">}</span>
</code></pre></div></div>

<p>The <code class="language-plaintext highlighter-rouge">loop</code> loop is used when you want to run your loop indefinitely until a terminating statement is reached. An example of when this would come in handy is when you have a web server with request handlers each assigned a thread. In a case like this you wouldn’t want to have this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">let</span> <span class="n">status</span><span class="p">:</span> <span class="nb">bool</span> <span class="o">=</span> <span class="k">true</span><span class="p">;</span>

<span class="k">while</span> <span class="k">true</span> <span class="p">{</span>
  <span class="c1">// add some case that can set `status` to false</span>
<span class="p">}</span>
</code></pre></div></div>

<p>When you could actually have this:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="k">loop</span> <span class="p">{</span>
  <span class="c1">// add some case that can break out of the loop</span>
<span class="p">}</span>
</code></pre></div></div>

<blockquote>
  <p>“Rust’s control-flow analysis treats this construct differently than a while true, since we know that it will always loop. In general, the more information we can give to the compiler, the better it can do with safety and code generation, so you should always prefer loop when you plan to loop infinitely” - Quoted from https://doc.rust-lang.org/book/loops.html</p>
</blockquote>

<p>Here’s one more thing you’d probably like about loops in Rust. Loops can have labels. Labels are extremely useful when working with nested loops. Here’s a JavaScript example:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="n">var</span> <span class="n">status1</span> <span class="o">=</span> <span class="k">true</span><span class="p">;</span>
<span class="n">var</span> <span class="n">status2</span> <span class="o">=</span> <span class="k">true</span><span class="p">;</span>

<span class="k">while</span> <span class="p">(</span><span class="n">status1</span><span class="p">)</span> <span class="p">{</span>
  <span class="k">while</span> <span class="p">(</span><span class="n">status2</span><span class="p">)</span> <span class="p">{</span>
    <span class="n">status1</span> <span class="o">=</span> <span class="k">false</span><span class="p">;</span>
    <span class="n">status2</span> <span class="o">=</span> <span class="k">false</span><span class="p">;</span>
  <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<p>The snippet above can be written with labels as follows:</p>

<div class="language-rust highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nv">'outer_loop</span><span class="p">:</span> <span class="k">loop</span> <span class="p">{</span>
  <span class="nv">'inner_loop</span><span class="p">:</span> <span class="k">loop</span> <span class="p">{</span>
    <span class="k">break</span> <span class="nv">'outer_loop</span><span class="p">;</span>
  <span class="p">}</span>
<span class="p">}</span>
</code></pre></div></div>

<p>Read more about loops <a href="https://doc.rust-lang.org/book/loops.html">here</a>.</p>

<p>I think I’ve covered enough in this post and will stop right here. More stuff is coming in upcoming posts though, so stay tuned.</p>]]></content><author><name>Fadi Hanna Al-Kass</name></author><category term="Rust" /><summary type="html"><![CDATA[So you’ve been doing high-level programming all your life, and you’ve been eyeing Rust for some time now, and you’re not sure where to start (or how to start). Well, this walk-through-like post will guide you through some of the common tasks you preform in high-level languages like JavaScript, Python, or even C#.]]></summary></entry></feed>