ArrowMap implementation in Haskell and C++

arrow_map.hpp

#pragma once

#include <functional>
#include <optional>

template <typename K, typename V>
class arrow_map
{
public:

    using opt_value = std::optional<V>;

    opt_value lookup(K&& key) {
        return func(key);
    }

    void insert(K&& key, V&& value) {
        func = [key = std::move(key), value = std::move(value), func = std::move(func)] (const K& k) -> opt_value {
            if (k == key) {
                return std::make_optional(value);
            }

            return func(k);
        };
    }

    void remove(K&& key) {
        func = [key = std::move(key), func = std::move(func)] (const K& k) -> opt_value {
            if (k == key) {
                return std::nullopt;
            }

            return func(k);
        };
    }

private:

    std::function<opt_value(const K&)> func {[] (const K&) -> opt_value { return std::nullopt; } };
};

ArrowMap.hs

import Prelude hiding (lookup)

class MapLike m where
    empty :: m k v
    lookup :: Ord k => k -> m k v -> Maybe v
    insert :: Ord k => k -> v -> m k v -> m k v
    delete :: Ord k => k -> m k v -> m k v
    fromList :: Ord k => [(k,v)] -> m k v

newtype ArrowMap k v = ArrowMap { getArrowMap :: k -> Maybe v }

instance MapLike ArrowMap where
    empty = ArrowMap (\_ -> Nothing)
    lookup k (ArrowMap f) = f k
    insert k v (ArrowMap f) = ArrowMap (\key -> if key == k then Just v else f key)
    delete k (ArrowMap f) = ArrowMap (\key -> if key == k then Nothing else f key)
    fromList [] = empty
    fromList ((k,v):xs) = insert k v (fromList xs)