Scala provides some simple options to get up and running the development of domain specific languages. In today’s post, I’ll take you through the usage of the implicit keyword that easily allows for this to happen.
End goal
For the purposes of today, I want to create a language that defines simple, directional instructions. “Move left”, “move forward”, etc. The end goal, I want a language that looks like this:
var jump = 5.0 units up
var shuffle = -2.0 units left
var fall = -6000.0 units down
Implicit conversion
The implicit conversion will allow us to get this process started. It’ll provide the ability for us to take that literal, double value (at the start of each of those statements), and convert them into a class instance that we can do more interesting things with.
Ok, so we don’t know what a DirectionUtil class is just yet. That’s coming. Right now, it’s important to focus on this function which is an implicit conversion; allows us to express a double-value like normal and have Scala treat it as a DirectionUtil instance.
. . which, as expected gives us an output like this:
(0.0,-5.0,0.0)
In closing
This is a really simple example, but you can see immediately how it can be applied to much more complex scenarios; and how you can be a lot more expressive in your scala source code.
In a previous article, we’d spent a little bit of time working with maps in clojure; we also looked at formalising the structure of a map into records. In today’s post, I’ll discuss some of the collection types that will allows us to carry around many values at once.
General
Before we start looking at the collection types, there are some general-purpose functions that you can use with these types. These are very helpful functions that really form the basis of your collection processing:
first will return you the head of your collection; with rest providing you with everything else but the head. last will return you the final item in your collection and cons will provide you with the ability to construct a new list with a given head and tail.
nth will give you indexed access to you collection.
List
A list is an ordered collection of elements. From the documentation:
Lists are collections. They implement the ISeq interface directly (except for the empty list, which is not a valid seq). count is O(1). conj puts the item at the front of the list.
Because lists are a natural part of the language, they’ll be invoked as a function if they’re not defined correctly or quoted adequately. A list can be defined using the list function, but can also be quoted:
A vector is an ordered collection of elements, but is optimised for the random-access case. From the documentation:
A Vector is a collection of values indexed by contiguous integers. Vectors support access to items by index in log32N hops. count is O(1). conj puts the item at the end of the vector.
Sets have methods to easily union two sets, or find the difference.
Map
Definition
A map is a collection of key-value-pairs. Declaring maps allows you to define attribute keys and values in an organised or arbitrary way. From the documentation:
A Map is a collection that maps keys to values. Two different map types are provided - hashed and sorted. Hash maps require keys that correctly support hashCode and equals. Sorted maps require keys that implement Comparable, or an instance of Comparator. Hash maps provide faster access (log32N hops) vs (logN hops), but sorted maps are, well, sorted. count is O(1). conj expects another (possibly single entry) map as the item, and returns a new map which is the old map plus the entries from the new, which may overwrite entries of the old.
We’re afforded all of the same functions above to work on this value; but we’re given the positional factory function ->Constructor so that we can construct our types in a much more intuitive way.
Domain functions
Now that we’ve spent a little bit of time creating data structures and defining data records, we can create functions that will allow us to perform operations on this data. Domain functions in Clojure perform operations specific to the data structure. In this following example, we’ve created a function to format a person’s full name:
user=> (defn get-full-name [p] (str (get p :first-name) " " (get p :last-name)))
#'user/get-name
user=> (user/get-full-name person)
"John Smith"
Object-oriented programming gives us polymorphism by allowing us to implement a class’s method differently per type that we derive from a common base. Clojure, gives us this multi-dispatch effect (choosing the right function for the given data-type) through multi methods and protocols.
Multi-methods
We’re going to use the defmulti macro to define our multi method and we’ll provide implementations using the defmethod macro. From the documentation:
Clojure eschews the traditional object-oriented approach of creating a new data type for each new situation, instead preferring to build a large library of functions on a small set of types. However, Clojure fully recognizes the value of runtime polymorphism in enabling flexible and extensible system architecture. Clojure supports sophisticated runtime polymorphism through a multimethod system that supports dispatching on types, values, attributes and metadata of, and relationships between, one or more arguments.
We’re going to expand the Person example above, by adding a new record of Company.
user=> (defrecord Person [first-name last-name age])
user=> (defrecord Company [name number])
Then we’ll define our multi method called get-full-name. Its job is to put together the name of our entity. Because we have both a Person and Company type entity, we’re going to need two different implementations:
user=> (defmulti get-full-name (fn [entity] (class entity)))
user=> (defmethod get-full-name Person [person] (str (get person :first-name) " " (get person :last-name)))
user=> (defmethod get-full-name Company [company] (get company :name))
The Person implementation of the get-full-name function concatenates the :first-name and :last-name attributes together, where as the Company implementation need only return the :name attribute.
Something that is interesting and unique to multi-methods is value-based dispatch; we’ve already seen type-based dispatch.
Consider a temperature conversion between Fahrenheit and Celsius. We create our multi method the same way, but this time we need to give the parameter values identity:
We can now give our multi method some implementations based on the source and destination units passed:
;; C to F
(defmethod convert-temp [:c :f] [_ _ c] (+ 32 (* c 1.8)))
;; F to C
(defmethod convert-temp [:f :c] [_ _ f] (/ (- f 32) 1.8))
;; anything else
(defmethod convert-temp :default
[su du a]
(if (= su du)
a
(assert false "Conversion between units was not defined")))
We can now test out that the dispatching works:
user=> (convert-temp :f :c 100)
37.77777777777778
user=> (convert-temp :c :f 37.77777777777778)
100.0
user=> (convert-temp :c :c 50)
50
user=> (convert-temp :c :k 50)
AssertionError Assert failed: Conversion between units was not defined
false user/eval1317/fn--1318 (form-init7827911538193486373.clj:1)
Protocols
Protocols are a little more reminiscent of object-oriented programming in a sense that they are closely related to interfaces. From the documentation:
Clojure is written in terms of abstractions. There are abstractions for sequences, collections, callability, etc. In addition, Clojure supplies many implementations of these abstractions. The abstractions are specified by host interfaces, and the implementations by host classes. While this was sufficient for bootstrapping the language, it left Clojure without similar abstraction and low-level implementation facilities. The protocols and datatypes features add powerful and flexible mechanisms for abstraction and data structure definition with no compromises vs the facilities of the host platform.
So, protocols give us a way to defining abstractions. We can treat our Person and Company scenario as such, by calling them a Party.
We use defprotocol to start our abstraction definition. extend-protocol is then used to supply implementations.
user=> (defprotocol Party
#_=> (get-full-name [entity]))
user=> (extend-protocol Party
#_=> Person
#_=> (get-full-name [person] (str (get person :first-name) " " (get person :last-name))))
user=> (extend-protocol Party
#_=> Company
#_=> (get-full-name [company] (get company :name)))
Wrapping up
This has been a brief tour on creating map/record data and some domain functions to work with them.
scipy is a specialist library for dealing with mathematical, science and engineering problems. According to their website:
The SciPy library, a collection of numerical algorithms and domain-specific toolboxes, including signal processing, optimization, statistics and much more.
The library itself is such a broad topic, so for the purposes of today’s article I just want to focus on a few items (from numpy) listed in their basic functions area covering polynomials and then finish up with the integration library.
Polynomials
A quick brush-up on some high school math (thanks wikipedia) tells us that a polynomial is an expression of more than two algebraic terms; these are normally variables (or indeterminates) and co-efficients.
Our polynomial with just one variable:
x² + 3x + 1
Let’s get scipy to represent this for us:
importnumpyasnpp1=np.poly1d([1,3,1])print(p1)
This gives us an output of:
2
1 x + 3 x + 1
Derivative
Lets derive this function, to find the formula that defines its instantaneous rate of change:
f(x) = x² + 3x + 1
f'(x) = 2x + 3
We can get scipy to this for us using the deriv function:
print(p1.deriv())
Confirming everything for us, we now receive the derivative:
2 x + 3
Integral
We’ll integrate the same function now, providing us with the ability to calculate the area under the curve that the original polynomial would provide:
f(x) = x² + 3x + 1
∫f(x) = x³ / 3 + (3x²) / 2 + x + C
We can simply use the integ function to do this for us, again:
print(p1.integ())
Providing us with the following answer:
3 2
0.3333 x + 1.5 x + 1 x
General integration
Now that we’ve done some basic calculus with polynomials, we’ll get scipy to perform the integration for us. Using quad we specify the function that produces our values a maxima and minima value and then we’re given the integrated values.
Getting your program to make simple HTTP has become a feature that is just a given these days. The python library requests makes life a lot easier.
Requests is the only Non-GMO HTTP library for Python, safe for human consumption.
Today’s post will focus on this library, to show you how you can be immediately productive.
How things were
One of the best comparisons comes directly from the requests documentation. Prior to its existence, you needed to do the following to perform a GET request with Basic Authentication: