This is an "oldie but a goodie". It's super easy.

A dictionary is a data structure that represents a map from keys to values. The question is, can this data structure and its characteristic operations be encoded using only functions?

The answer of course is yes and indeed, here's one such an encoding in OCaml.

(*The type of a dictionary with keys of type [α] and values of type [β]*) type (α, β) dict = α -> β option (*The empty dictionary maps every key to [None]*) let empty (k : α) : β option = None (*[add d k v] is the dictionary [d] together with a binding of [k] to [v]*) let add (d : (α, β) dict) (k : α) (v : β) : (α, β) dict = fun l -> if l = k then Some v else d l (*[find d k] retrieves the value bound to [k]*) let find (d : (α, β) dict) (k : α) : β option = d kTest it like this.

(*e.g. Name | Age ================================+==== "Felonius Gru" | 53 "Dave the Minion" | 4.54e9 "Dr. Joseph Albert Nefario" | 80 *) let despicable = add (add (add empty "Felonius Gru" 53 ) "Dave the Minion" (int_of_float 4.54e9) ) "Dr. Nefario" 80 let _ = find despicable "Dave the Minion" |> function | Some x -> x | _ -> failwith "Not found"

Moving on, can we implement this in C++? Sure. Here's one way.

#include <pgs/pgs.hpp> #include <functional> #include <iostream> #include <cstdint> using namespace pgs; // -- A rough and ready `'a option` (given the absence of // `std::experimental::optional` struct None {}; template <class A> struct Some { A val; template <class Arg> explicit Some (Arg&& s) : val { std::forward<Arg> (s) } {} }; template <class B> using option = sum_type<None, Some<B>>; template <class B> std::ostream& operator << (std::ostream& os, option<B> const& o) { return o.match<std::ostream&>( [&](Some<B> const& a) -> std::ostream& { return os << a.val; }, [&](None) -> std::ostream& { return os << "<empty>"; } ); } //-- Encoding of dictionaries as functions template <class K, class V> using dict_type = std::function<option<V>(K)>; //`empty` is a dictionary constant (a function that maps any key to //`None`) template <class A, class B> dict_type<A, B> empty = [](A const&) { return option<B>{ constructor<None>{} }; }; //`add (d, k, v)` extends `d` with a binding of `k` to `v` template <class A, class B> dict_type<A, B> add (dict_type<A, B> const& d, A const& k, B const& v) { return [=](A const& l) { return (k == l) ? option<B>{ constructor<Some<B>>{}, v} : d (l); }; } //`find (d, k)` searches for a binding in `d` for `k` template <class A, class B> option<B> find (dict_type<A, B> const& d, A const& k) { return d (k); } //-- Test driver int main () { using dict_t = dict_type<std::string, std::int64_t>; auto nil = empty<std::string, std::int64_t>; dict_t(*insert)(dict_t const&, std::string const&, std::int64_t const&) = &add; dict_t despicable = insert ( insert ( insert (nil , std::string {"Felonius Gru"}, std::int64_t{53}) , std::string {"Dave the Minion"}, std::int64_t{4530000000}) , std::string {"Dr. Joseph Albert Nefario"}, std::int64_t{80}) ; std::cout << find (despicable, std::string {"Dave the Minion"}) << std::endl; return 0; }