diff --git a/javaslang/src/main/java/javaslang/collection/AbstractMap.java b/javaslang/src/main/java/javaslang/collection/AbstractMap.java
deleted file mode 100644
index 9d23580ead..0000000000
--- a/javaslang/src/main/java/javaslang/collection/AbstractMap.java
+++ /dev/null
@@ -1,312 +0,0 @@
-/*     / \____  _    _  ____   ______  / \ ____  __    _______
- *    /  /    \/ \  / \/    \ /  /\__\/  //    \/  \  //  /\__\   JΛVΛSLΛNG
- *  _/  /  /\  \  \/  /  /\  \\__\\  \  //  /\  \ /\\/ \ /__\ \   Copyright 2014-2016 Javaslang, http://javaslang.io
- * /___/\_/  \_/\____/\_/  \_/\__\/__/\__\_/  \_//  \__/\_____/   Licensed under the Apache License, Version 2.0
- */
-package javaslang.collection;
-
-import javaslang.Tuple;
-import javaslang.Tuple2;
-import javaslang.control.Option;
-
-import java.util.Comparator;
-import java.util.Objects;
-import java.util.function.*;
-
-/**
- * An abstract {@link Map} implementation (not intended to be public).
- *
- * @param <K> Key type
- * @param <V> Value type
- * @param <M> Map type
- * @author Ruslan Sennov
- * @since 2.0.0
- */
-abstract class AbstractMap<K, V, M extends AbstractMap<K, V, M>> implements Map<K, V> {
-
-    private static final long serialVersionUID = 1L;
-
-    abstract M createFromEntries(Iterable<? extends Tuple2<? extends K, ? extends V>> entries);
-
-    /**
-     * Returns an empty version of this traversable, i.e. {@code empty().isEmpty() == true}.
-     *
-     * @return an empty instance of this Map.
-     */
-    abstract M emptyInstance();
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public M put(Tuple2<? extends K, ? extends V> entry) {
-        Objects.requireNonNull(entry, "entry is null");
-        return (M) put(entry._1, entry._2);
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public <U extends V> M put(K key, U value,
-                               BiFunction<? super V, ? super U, ? extends V> merge) {
-        Objects.requireNonNull(merge, "the merge function is null");
-        final Option<V> currentValue = get(key);
-        if (currentValue.isEmpty()) {
-            return (M) put(key, value);
-        } else {
-            return (M) put(key, merge.apply(currentValue.get(), value));
-        }
-    }
-
-    @Override
-    public <U extends V> M put(Tuple2<? extends K, U> entry,
-                               BiFunction<? super V, ? super U, ? extends V> merge) {
-        Objects.requireNonNull(merge, "the merge function is null");
-        final Option<V> currentValue = get(entry._1);
-        if (currentValue.isEmpty()) {
-            return put(entry);
-        } else {
-            return put(entry.map2(
-                    value -> merge.apply(currentValue.get(), value)));
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public M distinct() {
-        return (M) this;
-    }
-
-    @Override
-    public M distinctBy(Comparator<? super Tuple2<K, V>> comparator) {
-        Objects.requireNonNull(comparator, "comparator is null");
-        return createFromEntries(iterator().distinctBy(comparator));
-    }
-
-    @Override
-    public <U> M distinctBy(Function<? super Tuple2<K, V>, ? extends U> keyExtractor) {
-        Objects.requireNonNull(keyExtractor, "keyExtractor is null");
-        return createFromEntries(iterator().distinctBy(keyExtractor));
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public M drop(int n) {
-        if (n <= 0) {
-            return (M) this;
-        } else if (n >= length()) {
-            return emptyInstance();
-        } else {
-            return createFromEntries(iterator().drop(n));
-        }
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public M dropRight(int n) {
-        if (n <= 0) {
-            return (M) this;
-        } else if (n >= length()) {
-            return emptyInstance();
-        } else {
-            return createFromEntries(iterator().dropRight(n));
-        }
-    }
-
-    @Override
-    public M dropUntil(Predicate<? super Tuple2<K, V>> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        return dropWhile(predicate.negate());
-    }
-
-    @Override
-    public M dropWhile(Predicate<? super Tuple2<K, V>> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        return createFromEntries(iterator().dropWhile(predicate));
-    }
-
-    @Override
-    public M filter(Predicate<? super Tuple2<K, V>> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        return createFromEntries(iterator().filter(predicate));
-    }
-
-    @Override
-    public M filter(BiPredicate<? super K, ? super V> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        return filter(t -> predicate.test(t._1, t._2));
-    }
-
-    @Override
-    public M filterKeys(Predicate<? super K> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        return filter(t -> predicate.test(t._1));
-    }
-
-    @Override
-    public M filterValues(Predicate<? super V> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        return filter(t -> predicate.test(t._2));
-    }
-
-    @Override
-    public M removeAll(BiPredicate<? super K, ? super V> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        return filter(predicate.negate());
-    }
-
-    @Override
-    public M removeKeys(Predicate<? super K> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        return filterKeys(predicate.negate());
-    }
-
-    @Override
-    public M removeValues(Predicate<? super V> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        return filterValues(predicate.negate());
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public <C> Map<C, M> groupBy(Function<? super Tuple2<K, V>, ? extends C> classifier) {
-        return Collections.groupBy(this, classifier, this::createFromEntries);
-    }
-
-    @Override
-    public Iterator<M> grouped(int size) {
-        return sliding(size, size);
-    }
-
-    @Override
-    public abstract M init();
-
-    @Override
-    public Option<M> initOption() {
-        return isEmpty() ? Option.none() : Option.some(init());
-    }
-
-    @Override
-    public abstract M tail();
-
-    @Override
-    public Option<M> tailOption() {
-        return isEmpty() ? Option.none() : Option.some(tail());
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public M take(int n) {
-        if (size() <= n) {
-            return (M) this;
-        } else {
-            return createFromEntries(iterator().take(n));
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public M takeRight(int n) {
-        if (size() <= n) {
-            return (M) this;
-        } else {
-            return createFromEntries(iterator().takeRight(n));
-        }
-    }
-
-    @Override
-    public M takeUntil(Predicate<? super Tuple2<K, V>> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        return takeWhile(predicate.negate());
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public M takeWhile(Predicate<? super Tuple2<K, V>> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        final M taken = createFromEntries(iterator().takeWhile(predicate));
-        return taken.length() == length() ? (M) this : taken;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public M merge(Map<? extends K, ? extends V> that) {
-        Objects.requireNonNull(that, "that is null");
-        if (isEmpty()) {
-            return createFromEntries(that);
-        } else if (that.isEmpty()) {
-            return (M) this;
-        } else {
-            return that.foldLeft((M) this, (map, entry) -> !map.containsKey(entry._1) ? map.put(entry) : map);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public <U extends V> M merge(Map<? extends K, U> that, BiFunction<? super V, ? super U, ? extends V> collisionResolution) {
-        Objects.requireNonNull(that, "that is null");
-        Objects.requireNonNull(collisionResolution, "collisionResolution is null");
-        if (isEmpty()) {
-            return createFromEntries(that);
-        } else if (that.isEmpty()) {
-            return (M) this;
-        } else {
-            return that.foldLeft((M) this, (map, entry) -> {
-                final K key = entry._1;
-                final U value = entry._2;
-                final V newValue = map.get(key).map(v -> (V) collisionResolution.apply(v, value)).getOrElse(value);
-                return (M) map.put(key, newValue);
-            });
-        }
-    }
-
-    @Override
-    public Tuple2<M, M> partition(Predicate<? super Tuple2<K, V>> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        final Tuple2<Iterator<Tuple2<K, V>>, Iterator<Tuple2<K, V>>> p = iterator().partition(predicate);
-        return Tuple.of(createFromEntries(p._1), createFromEntries(p._2));
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public M peek(Consumer<? super Tuple2<K, V>> action) {
-        Objects.requireNonNull(action, "action is null");
-        if (!isEmpty()) {
-            action.accept(head());
-        }
-        return (M) this;
-    }
-
-    @SuppressWarnings("unchecked")
-    @Override
-    public M replace(Tuple2<K, V> currentElement, Tuple2<K, V> newElement) {
-        Objects.requireNonNull(currentElement, "currentElement is null");
-        Objects.requireNonNull(newElement, "newElement is null");
-        return (M) (containsKey(currentElement._1) ? remove(currentElement._1).put(newElement) : this);
-    }
-
-    @Override
-    public M replaceAll(Tuple2<K, V> currentElement, Tuple2<K, V> newElement) {
-        return replace(currentElement, newElement);
-    }
-
-    @Override
-    public M scan(Tuple2<K, V> zero, BiFunction<? super Tuple2<K, V>, ? super Tuple2<K, V>, ? extends Tuple2<K, V>> operation) {
-        Objects.requireNonNull(operation, "operation is null");
-        return Collections.scanLeft(this, zero, operation, emptyInstance(), (m, e) -> m.put(e), Function.identity());
-    }
-
-    @Override
-    public Iterator<M> sliding(int size) {
-        return sliding(size, 1);
-    }
-
-    @Override
-    public Iterator<M> sliding(int size, int step) {
-        return iterator().sliding(size, step).map(this::createFromEntries);
-    }
-
-    @Override
-    public Tuple2<M, M> span(Predicate<? super Tuple2<K, V>> predicate) {
-        Objects.requireNonNull(predicate, "predicate is null");
-        final Tuple2<Iterator<Tuple2<K, V>>, Iterator<Tuple2<K, V>>> t = iterator().span(predicate);
-        return Tuple.of(createFromEntries(t._1), createFromEntries(t._2));
-    }
-}
diff --git a/javaslang/src/main/java/javaslang/collection/HashMap.java b/javaslang/src/main/java/javaslang/collection/HashMap.java
index a53dc67b3e..5eddbeb3bd 100644
--- a/javaslang/src/main/java/javaslang/collection/HashMap.java
+++ b/javaslang/src/main/java/javaslang/collection/HashMap.java
@@ -5,11 +5,16 @@
  */
 package javaslang.collection;
 
-import javaslang.*;
+import javaslang.Kind2;
+import javaslang.Tuple;
+import javaslang.Tuple2;
 import javaslang.control.Option;
 
 import java.io.Serializable;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.NoSuchElementException;
+import java.util.Objects;
 import java.util.function.*;
 import java.util.stream.Collector;
 
@@ -20,7 +25,7 @@
  * @author Ruslan Sennov, Patryk Najda, Daniel Dietrich
  * @since 2.0.0
  */
-public final class HashMap<K, V> extends AbstractMap<K, V, HashMap<K, V>> implements Kind2<HashMap<?, ?>, K, V>, Serializable {
+public final class HashMap<K, V> implements Kind2<HashMap<?, ?>, K, V>, Map<K, V>, Serializable {
 
     private static final long serialVersionUID = 1L;
 
@@ -225,16 +230,6 @@ public static <K, V> HashMap<K, V> ofEntries(Iterable<? extends Tuple2<? extends
         }
     }
 
-    @Override
-    HashMap<K, V> createFromEntries(Iterable<? extends Tuple2<? extends K, ? extends V>> entries) {
-        return HashMap.ofEntries(entries);
-    }
-
-    @Override
-    HashMap<K, V> emptyInstance() {
-        return HashMap.empty();
-    }
-
     @Override
     public <K2, V2> HashMap<K2, V2> bimap(Function<? super K, ? extends K2> keyMapper, Function<? super V, ? extends V2> valueMapper) {
         Objects.requireNonNull(keyMapper, "keyMapper is null");
@@ -248,6 +243,61 @@ public boolean containsKey(K key) {
         return trie.containsKey(key);
     }
 
+    @Override
+    public HashMap<K, V> distinct() {
+        return Maps.distinct(this);
+    }
+
+    @Override
+    public HashMap<K, V> distinctBy(Comparator<? super Tuple2<K, V>> comparator) {
+        return Maps.distinctBy(this, this::createFromEntries, comparator);
+    }
+
+    @Override
+    public <U> HashMap<K, V> distinctBy(Function<? super Tuple2<K, V>, ? extends U> keyExtractor) {
+        return Maps.distinctBy(this, this::createFromEntries, keyExtractor);
+    }
+
+    @Override
+    public HashMap<K, V> drop(int n) {
+        return Maps.drop(this, this::createFromEntries, HashMap::empty, n);
+    }
+
+    @Override
+    public HashMap<K, V> dropRight(int n) {
+        return Maps.dropRight(this, this::createFromEntries, HashMap::empty, n);
+    }
+
+    @Override
+    public HashMap<K, V> dropUntil(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.dropUntil(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public HashMap<K, V> dropWhile(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.dropWhile(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public HashMap<K, V> filter(BiPredicate<? super K, ? super V> predicate) {
+        return Maps.filter(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public HashMap<K, V> filter(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.filter(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public HashMap<K, V> filterKeys(Predicate<? super K> predicate) {
+        return Maps.filterKeys(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public HashMap<K, V> filterValues(Predicate<? super V> predicate) {
+        return Maps.filterValues(this, this::createFromEntries, predicate);
+    }
+
     @Override
     public <K2, V2> HashMap<K2, V2> flatMap(BiFunction<? super K, ? super V, ? extends Iterable<Tuple2<K2, V2>>> mapper) {
         Objects.requireNonNull(mapper, "mapper is null");
@@ -264,6 +314,16 @@ public Option<V> get(K key) {
         return trie.get(key);
     }
 
+    @Override
+    public <C> Map<C, HashMap<K, V>> groupBy(Function<? super Tuple2<K, V>, ? extends C> classifier) {
+        return Maps.groupBy(this, this::createFromEntries, classifier);
+    }
+
+    @Override
+    public Iterator<HashMap<K, V>> grouped(int size) {
+        return Maps.grouped(this, this::createFromEntries, size);
+    }
+
     @Override
     public Tuple2<K, V> head() {
         if (isEmpty()) {
@@ -282,6 +342,11 @@ public HashMap<K, V> init() {
         }
     }
 
+    @Override
+    public Option<HashMap<K, V>> initOption() {
+        return Maps.initOption(this);
+    }
+
     @Override
     public boolean isEmpty() {
         return trie.isEmpty();
@@ -320,17 +385,59 @@ public <V2> HashMap<K, V2> mapValues(Function<? super V, ? extends V2> valueMapp
         return map((k, v) -> Tuple.of(k, valueMapper.apply(v)));
     }
 
+    @Override
+    public HashMap<K, V> merge(Map<? extends K, ? extends V> that) {
+        return Maps.merge(this, this::createFromEntries, that);
+    }
+
+    @Override
+    public <U extends V> HashMap<K, V> merge(Map<? extends K, U> that,
+                                             BiFunction<? super V, ? super U, ? extends V> collisionResolution) {
+        return Maps.merge(this, this::createFromEntries, that, collisionResolution);
+    }
+
+    @Override
+    public Tuple2<HashMap<K, V>, HashMap<K, V>> partition(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.partition(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public HashMap<K, V> peek(Consumer<? super Tuple2<K, V>> action) {
+        return Maps.peek(this, action);
+    }
+
+    @Override
+    public <U extends V> HashMap<K, V> put(K key, U value, BiFunction<? super V, ? super U, ? extends V> merge) {
+        return Maps.put(this, key, value, merge);
+    }
+
     @Override
     public HashMap<K, V> put(K key, V value) {
         return new HashMap<>(trie.put(key, value));
     }
 
+    @Override
+    public HashMap<K, V> put(Tuple2<? extends K, ? extends V> entry) {
+        return Maps.put(this, entry);
+    }
+
+    @Override
+    public <U extends V> HashMap<K, V> put(Tuple2<? extends K, U> entry,
+                                           BiFunction<? super V, ? super U, ? extends V> merge) {
+        return Maps.put(this, entry, merge);
+    }
+
     @Override
     public HashMap<K, V> remove(K key) {
         final HashArrayMappedTrie<K, V> result = trie.remove(key);
         return result.size() == trie.size() ? this : wrap(result);
     }
 
+    @Override
+    public HashMap<K, V> removeAll(BiPredicate<? super K, ? super V> predicate) {
+        return Maps.removeAll(this, this::createFromEntries, predicate);
+    }
+
     @Override
     public HashMap<K, V> removeAll(Iterable<? extends K> keys) {
         Objects.requireNonNull(keys, "keys is null");
@@ -348,6 +455,26 @@ public HashMap<K, V> removeAll(Iterable<? extends K> keys) {
         }
     }
 
+    @Override
+    public HashMap<K, V> removeKeys(Predicate<? super K> predicate) {
+        return Maps.removeKeys(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public HashMap<K, V> removeValues(Predicate<? super V> predicate) {
+        return Maps.removeValues(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public HashMap<K, V> replace(Tuple2<K, V> currentElement, Tuple2<K, V> newElement) {
+        return Maps.replace(this, currentElement, newElement);
+    }
+
+    @Override
+    public HashMap<K, V> replaceAll(Tuple2<K, V> currentElement, Tuple2<K, V> newElement) {
+        return Maps.replaceAll(this, currentElement, newElement);
+    }
+
     @Override
     public HashMap<K, V> retainAll(Iterable<? extends Tuple2<K, V>> elements) {
         Objects.requireNonNull(elements, "elements is null");
@@ -360,11 +487,33 @@ public HashMap<K, V> retainAll(Iterable<? extends Tuple2<K, V>> elements) {
         return wrap(tree);
     }
 
+    @Override
+    public HashMap<K, V> scan(
+            Tuple2<K, V> zero,
+            BiFunction<? super Tuple2<K, V>, ? super Tuple2<K, V>, ? extends Tuple2<K, V>> operation) {
+        return Maps.scan(this, HashMap::empty, zero, operation);
+    }
+
     @Override
     public int size() {
         return trie.size();
     }
 
+    @Override
+    public Iterator<HashMap<K, V>> sliding(int size) {
+        return Maps.sliding(this, this::createFromEntries, size);
+    }
+
+    @Override
+    public Iterator<HashMap<K, V>> sliding(int size, int step) {
+        return Maps.sliding(this, this::createFromEntries, size, step);
+    }
+
+    @Override
+    public Tuple2<HashMap<K, V>, HashMap<K, V>> span(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.span(this, this::createFromEntries, predicate);
+    }
+
     @Override
     public HashMap<K, V> tail() {
         if (trie.isEmpty()) {
@@ -374,6 +523,31 @@ public HashMap<K, V> tail() {
         }
     }
 
+    @Override
+    public Option<HashMap<K, V>> tailOption() {
+        return Maps.tailOption(this);
+    }
+
+    @Override
+    public HashMap<K, V> take(int n) {
+        return Maps.take(this, this::createFromEntries, n);
+    }
+
+    @Override
+    public HashMap<K, V> takeRight(int n) {
+        return Maps.takeRight(this, this::createFromEntries, n);
+    }
+
+    @Override
+    public HashMap<K, V> takeUntil(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.takeUntil(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public HashMap<K, V> takeWhile(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.takeWhile(this, this::createFromEntries, predicate);
+    }
+
     @Override
     public java.util.HashMap<K, V> toJavaMap() {
         return toJavaMap(java.util.HashMap::new, t -> t);
@@ -418,4 +592,10 @@ public String toString() {
     private static <K, V> HashMap<K, V> wrap(HashArrayMappedTrie<K, V> trie) {
         return trie.isEmpty() ? empty() : new HashMap<>(trie);
     }
+
+    // We need this method to narrow the argument of `ofEntries`.
+    // If this method is static with type args <K, V>, the jdk fails to infer types at the call site.
+    private HashMap<K, V> createFromEntries(Iterable<Tuple2<K, V>> tuples) {
+        return HashMap.ofEntries(tuples);
+    }
 }
diff --git a/javaslang/src/main/java/javaslang/collection/LinkedHashMap.java b/javaslang/src/main/java/javaslang/collection/LinkedHashMap.java
index 8ffb67bc2b..7313c76ac2 100644
--- a/javaslang/src/main/java/javaslang/collection/LinkedHashMap.java
+++ b/javaslang/src/main/java/javaslang/collection/LinkedHashMap.java
@@ -5,7 +5,6 @@
  */
 package javaslang.collection;
 
-import javaslang.Function2;
 import javaslang.Kind2;
 import javaslang.Tuple;
 import javaslang.Tuple2;
@@ -13,6 +12,7 @@
 
 import java.io.Serializable;
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.Objects;
 import java.util.function.*;
 import java.util.stream.Collector;
@@ -23,7 +23,7 @@
  * @author Ruslan Sennov
  * @since 2.0.0
  */
-public final class LinkedHashMap<K, V> extends AbstractMap<K, V, LinkedHashMap<K, V>> implements Kind2<LinkedHashMap<?, ?>, K, V>, Serializable {
+public final class LinkedHashMap<K, V> implements Kind2<LinkedHashMap<?, ?>, K, V>, Map<K, V>, Serializable {
 
     private static final long serialVersionUID = 1L;
 
@@ -240,16 +240,6 @@ public static <K, V> LinkedHashMap<K, V> ofEntries(Iterable<? extends Tuple2<? e
         }
     }
 
-    @Override
-    LinkedHashMap<K, V> createFromEntries(Iterable<? extends Tuple2<? extends K, ? extends V>> entries) {
-        return LinkedHashMap.ofEntries(entries);
-    }
-
-    @Override
-    LinkedHashMap<K, V> emptyInstance() {
-        return LinkedHashMap.empty();
-    }
-
     @Override
     public <K2, V2> LinkedHashMap<K2, V2> bimap(Function<? super K, ? extends K2> keyMapper, Function<? super V, ? extends V2> valueMapper) {
         Objects.requireNonNull(keyMapper, "keyMapper is null");
@@ -263,6 +253,61 @@ public boolean containsKey(K key) {
         return map.containsKey(key);
     }
 
+    @Override
+    public LinkedHashMap<K, V> distinct() {
+        return Maps.distinct(this);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> distinctBy(Comparator<? super Tuple2<K, V>> comparator) {
+        return Maps.distinctBy(this, this::createFromEntries, comparator);
+    }
+
+    @Override
+    public <U> LinkedHashMap<K, V> distinctBy(Function<? super Tuple2<K, V>, ? extends U> keyExtractor) {
+        return Maps.distinctBy(this, this::createFromEntries, keyExtractor);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> drop(int n) {
+        return Maps.drop(this, this::createFromEntries, LinkedHashMap::empty, n);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> dropRight(int n) {
+        return Maps.dropRight(this, this::createFromEntries, LinkedHashMap::empty, n);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> dropUntil(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.dropUntil(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> dropWhile(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.dropWhile(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> filter(BiPredicate<? super K, ? super V> predicate) {
+        return Maps.filter(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> filter(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.filter(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> filterKeys(Predicate<? super K> predicate) {
+        return Maps.filterKeys(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> filterValues(Predicate<? super V> predicate) {
+        return Maps.filterValues(this, this::createFromEntries, predicate);
+    }
+
     @Override
     public <K2, V2> LinkedHashMap<K2, V2> flatMap(BiFunction<? super K, ? super V, ? extends Iterable<Tuple2<K2, V2>>> mapper) {
         Objects.requireNonNull(mapper, "mapper is null");
@@ -279,6 +324,16 @@ public Option<V> get(K key) {
         return map.get(key);
     }
 
+    @Override
+    public <C> Map<C, LinkedHashMap<K, V>> groupBy(Function<? super Tuple2<K, V>, ? extends C> classifier) {
+        return Maps.groupBy(this, this::createFromEntries, classifier);
+    }
+
+    @Override
+    public Iterator<LinkedHashMap<K, V>> grouped(int size) {
+        return Maps.grouped(this, this::createFromEntries, size);
+    }
+
     @Override
     public Tuple2<K, V> head() {
         return list.head();
@@ -293,6 +348,11 @@ public LinkedHashMap<K, V> init() {
         }
     }
 
+    @Override
+    public Option<LinkedHashMap<K, V>> initOption() {
+        return Maps.initOption(this);
+    }
+
     @Override
     public boolean isEmpty() {
         return map.isEmpty();
@@ -331,6 +391,32 @@ public <W> LinkedHashMap<K, W> mapValues(Function<? super V, ? extends W> mapper
         return map((k, v) -> Tuple.of(k, mapper.apply(v)));
     }
 
+    @Override
+    public LinkedHashMap<K, V> merge(Map<? extends K, ? extends V> that) {
+        return Maps.merge(this, this::createFromEntries, that);
+    }
+
+    @Override
+    public <U extends V> LinkedHashMap<K, V> merge(Map<? extends K, U> that,
+                                                   BiFunction<? super V, ? super U, ? extends V> collisionResolution) {
+        return Maps.merge(this, this::createFromEntries, that, collisionResolution);
+    }
+
+    @Override
+    public Tuple2<LinkedHashMap<K, V>, LinkedHashMap<K, V>> partition(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.partition(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> peek(Consumer<? super Tuple2<K, V>> action) {
+        return Maps.peek(this, action);
+    }
+
+    @Override
+    public <U extends V> LinkedHashMap<K, V> put(K key, U value, BiFunction<? super V, ? super U, ? extends V> merge) {
+        return Maps.put(this, key, value, merge);
+    }
+
     @Override
     public LinkedHashMap<K, V> put(K key, V value) {
         Queue<Tuple2<K, V>> newList = list;
@@ -344,6 +430,17 @@ public LinkedHashMap<K, V> put(K key, V value) {
         return new LinkedHashMap<>(newList, newMap);
     }
 
+    @Override
+    public LinkedHashMap<K, V> put(Tuple2<? extends K, ? extends V> entry) {
+        return Maps.put(this, entry);
+    }
+
+    @Override
+    public <U extends V> LinkedHashMap<K, V> put(Tuple2<? extends K, U> entry,
+                                                 BiFunction<? super V, ? super U, ? extends V> merge) {
+        return Maps.put(this, entry, merge);
+    }
+
     @Override
     public LinkedHashMap<K, V> remove(K key) {
         if (containsKey(key)) {
@@ -355,6 +452,11 @@ public LinkedHashMap<K, V> remove(K key) {
         }
     }
 
+    @Override
+    public LinkedHashMap<K, V> removeAll(BiPredicate<? super K, ? super V> predicate) {
+        return Maps.removeAll(this, this::createFromEntries, predicate);
+    }
+
     @Override
     public LinkedHashMap<K, V> removeAll(Iterable<? extends K> keys) {
         Objects.requireNonNull(keys, "keys is null");
@@ -364,6 +466,26 @@ public LinkedHashMap<K, V> removeAll(Iterable<? extends K> keys) {
         return newList.size() == size() ? this : wrap(newList, newMap);
     }
 
+    @Override
+    public LinkedHashMap<K, V> removeKeys(Predicate<? super K> predicate) {
+        return Maps.removeKeys(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> removeValues(Predicate<? super V> predicate) {
+        return Maps.removeValues(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> replace(Tuple2<K, V> currentElement, Tuple2<K, V> newElement) {
+        return Maps.replace(this, currentElement, newElement);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> replaceAll(Tuple2<K, V> currentElement, Tuple2<K, V> newElement) {
+        return Maps.replaceAll(this, currentElement, newElement);
+    }
+
     @Override
     public LinkedHashMap<K, V> retainAll(Iterable<? extends Tuple2<K, V>> elements) {
         Objects.requireNonNull(elements, "elements is null");
@@ -376,11 +498,33 @@ public LinkedHashMap<K, V> retainAll(Iterable<? extends Tuple2<K, V>> elements)
         return result;
     }
 
+    @Override
+    public LinkedHashMap<K, V> scan(
+            Tuple2<K, V> zero,
+            BiFunction<? super Tuple2<K, V>, ? super Tuple2<K, V>, ? extends Tuple2<K, V>> operation) {
+        return Maps.scan(this, LinkedHashMap::empty, zero, operation);
+    }
+
     @Override
     public int size() {
         return map.size();
     }
 
+    @Override
+    public Iterator<LinkedHashMap<K, V>> sliding(int size) {
+        return Maps.sliding(this, this::createFromEntries, size);
+    }
+
+    @Override
+    public Iterator<LinkedHashMap<K, V>> sliding(int size, int step) {
+        return Maps.sliding(this, this::createFromEntries, size, step);
+    }
+
+    @Override
+    public Tuple2<LinkedHashMap<K, V>, LinkedHashMap<K, V>> span(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.span(this, this::createFromEntries, predicate);
+    }
+
     @Override
     public LinkedHashMap<K, V> tail() {
         if (isEmpty()) {
@@ -390,6 +534,31 @@ public LinkedHashMap<K, V> tail() {
         }
     }
 
+    @Override
+    public Option<LinkedHashMap<K, V>> tailOption() {
+        return Maps.tailOption(this);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> take(int n) {
+        return Maps.take(this, this::createFromEntries, n);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> takeRight(int n) {
+        return Maps.takeRight(this, this::createFromEntries, n);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> takeUntil(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.takeUntil(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public LinkedHashMap<K, V> takeWhile(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.takeWhile(this, this::createFromEntries, predicate);
+    }
+
     @Override
     public java.util.LinkedHashMap<K, V> toJavaMap() {
         return toJavaMap(java.util.LinkedHashMap::new, t -> t);
@@ -434,4 +603,11 @@ public String toString() {
     private static <K, V> LinkedHashMap<K, V> wrap(Queue<Tuple2<K, V>> list, HashMap<K, V> map) {
         return list.isEmpty() ? empty() : new LinkedHashMap<>(list, map);
     }
+
+    // We need this method to narrow the argument of `ofEntries`.
+    // If this method is static with type args <K, V>, the jdk fails to infer types at the call site.
+    private LinkedHashMap<K, V> createFromEntries(Iterable<Tuple2<K, V>> tuples) {
+        return LinkedHashMap.ofEntries(tuples);
+    }
+
 }
diff --git a/javaslang/src/main/java/javaslang/collection/Maps.java b/javaslang/src/main/java/javaslang/collection/Maps.java
new file mode 100644
index 0000000000..2005ae4af3
--- /dev/null
+++ b/javaslang/src/main/java/javaslang/collection/Maps.java
@@ -0,0 +1,275 @@
+/*     / \____  _    _  ____   ______  / \ ____  __    _______
+ *    /  /    \/ \  / \/    \ /  /\__\/  //    \/  \  //  /\__\   JΛVΛSLΛNG
+ *  _/  /  /\  \  \/  /  /\  \\__\\  \  //  /\  \ /\\/ \ /__\ \   Copyright 2014-2016 Javaslang, http://javaslang.io
+ * /___/\_/  \_/\____/\_/  \_/\__\/__/\__\_/  \_//  \__/\_____/   Licensed under the Apache License, Version 2.0
+ */
+package javaslang.collection;
+
+import javaslang.Tuple;
+import javaslang.Tuple2;
+import javaslang.control.Option;
+
+import java.util.Comparator;
+import java.util.Objects;
+import java.util.function.*;
+
+/**
+ * Implementations of common {@code Map} functions (not intended to be public).
+ *
+ * @author Ruslan Sennov, Daniel Dietrich
+ * @since 2.0.0
+ */
+final class Maps {
+
+    static <K, V, M extends Map<K, V>> M distinct(M map) {
+        return map;
+    }
+
+    static <K, V, M extends Map<K, V>> M distinctBy(M map, OfEntries<K, V, M> ofEntries,
+                                                    Comparator<? super Tuple2<K, V>> comparator) {
+        Objects.requireNonNull(comparator, "comparator is null");
+        return ofEntries.apply(map.iterator().distinctBy(comparator));
+    }
+
+    static <K, V, U, M extends Map<K, V>> M distinctBy(
+            M map, OfEntries<K, V, M> ofEntries, Function<? super Tuple2<K, V>, ? extends U> keyExtractor) {
+        Objects.requireNonNull(keyExtractor, "keyExtractor is null");
+        return ofEntries.apply(map.iterator().distinctBy(keyExtractor));
+    }
+
+    static <K, V, M extends Map<K, V>> M drop(M map, OfEntries<K, V, M> ofEntries, Supplier<M> emptySupplier, int n) {
+        if (n <= 0) {
+            return map;
+        } else if (n >= map.size()) {
+            return emptySupplier.get();
+        } else {
+            return ofEntries.apply(map.iterator().drop(n));
+        }
+    }
+
+    static <K, V, M extends Map<K, V>> M dropRight(M map, OfEntries<K, V, M> ofEntries, Supplier<M> emptySupplier,
+                                                   int n) {
+        if (n <= 0) {
+            return map;
+        } else if (n >= map.size()) {
+            return emptySupplier.get();
+        } else {
+            return ofEntries.apply(map.iterator().dropRight(n));
+        }
+    }
+
+    static <K, V, M extends Map<K, V>> M dropUntil(M map, OfEntries<K, V, M> ofEntries,
+                                                   Predicate<? super Tuple2<K, V>> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        return dropWhile(map, ofEntries, predicate.negate());
+    }
+
+    static <K, V, M extends Map<K, V>> M dropWhile(M map, OfEntries<K, V, M> ofEntries,
+                                                   Predicate<? super Tuple2<K, V>> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        return ofEntries.apply(map.iterator().dropWhile(predicate));
+    }
+
+    static <K, V, M extends Map<K, V>> M filter(M map, OfEntries<K, V, M> ofEntries,
+                                                BiPredicate<? super K, ? super V> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        return filter(map, ofEntries, t -> predicate.test(t._1, t._2));
+    }
+
+    static <K, V, M extends Map<K, V>> M filter(M map, OfEntries<K, V, M> ofEntries,
+                                                Predicate<? super Tuple2<K, V>> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        return ofEntries.apply(map.iterator().filter(predicate));
+    }
+
+    static <K, V, M extends Map<K, V>> M filterKeys(M map, OfEntries<K, V, M> ofEntries,
+                                                    Predicate<? super K> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        return filter(map, ofEntries, t -> predicate.test(t._1));
+    }
+
+    static <K, V, M extends Map<K, V>> M filterValues(M map, OfEntries<K, V, M> ofEntries,
+                                                      Predicate<? super V> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        return filter(map, ofEntries, t -> predicate.test(t._2));
+    }
+
+    static <K, V, C, M extends Map<K, V>> Map<C, M> groupBy(M map, OfEntries<K, V, M> ofEntries,
+                                                            Function<? super Tuple2<K, V>, ? extends C> classifier) {
+        return Collections.groupBy(map, classifier, ofEntries);
+    }
+
+    static <K, V, M extends Map<K, V>> Iterator<M> grouped(M map, OfEntries<K, V, M> ofEntries, int size) {
+        return sliding(map, ofEntries, size, size);
+    }
+
+    @SuppressWarnings("unchecked")
+    static <K, V, M extends Map<K, V>> Option<M> initOption(M map) {
+        return map.isEmpty() ? Option.none() : Option.some((M) map.init());
+    }
+
+    static <K, V, M extends Map<K, V>> M merge(M map, OfEntries<K, V, M> ofEntries,
+                                               Map<? extends K, ? extends V> that) {
+        Objects.requireNonNull(that, "that is null");
+        if (map.isEmpty()) {
+            return ofEntries.apply(Map.narrow(that));
+        } else if (that.isEmpty()) {
+            return map;
+        } else {
+            return that.foldLeft(map, (result, entry) -> !result.containsKey(entry._1) ? put(result, entry) : result);
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    static <K, V, U extends V, M extends Map<K, V>> M merge(
+            M map, OfEntries<K, V, M> ofEntries,
+            Map<? extends K, U> that, BiFunction<? super V, ? super U, ? extends V> collisionResolution) {
+        Objects.requireNonNull(that, "that is null");
+        Objects.requireNonNull(collisionResolution, "collisionResolution is null");
+        if (map.isEmpty()) {
+            return ofEntries.apply(Map.narrow(that));
+        } else if (that.isEmpty()) {
+            return map;
+        } else {
+            return that.foldLeft(map, (result, entry) -> {
+                final K key = entry._1;
+                final U value = entry._2;
+                final V newValue = result.get(key).map(v -> (V) collisionResolution.apply(v, value)).getOrElse(value);
+                return (M) result.put(key, newValue);
+            });
+        }
+    }
+
+    static <K, V, M extends Map<K, V>> Tuple2<M, M> partition(M map, OfEntries<K, V, M> ofEntries,
+                                                              Predicate<? super Tuple2<K, V>> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        final Tuple2<Iterator<Tuple2<K, V>>, Iterator<Tuple2<K, V>>> p = map.iterator().partition(predicate);
+        return Tuple.of(ofEntries.apply(p._1), ofEntries.apply(p._2));
+    }
+
+    static <K, V, M extends Map<K, V>> M peek(M map, Consumer<? super Tuple2<K, V>> action) {
+        Objects.requireNonNull(action, "action is null");
+        if (!map.isEmpty()) {
+            action.accept(map.head());
+        }
+        return map;
+    }
+
+    @SuppressWarnings("unchecked")
+    static <K, V, U extends V, M extends Map<K, V>> M put(M map, K key, U value,
+                                                          BiFunction<? super V, ? super U, ? extends V> merge) {
+        Objects.requireNonNull(merge, "the merge function is null");
+        final Option<V> currentValue = map.get(key);
+        if (currentValue.isEmpty()) {
+            return (M) map.put(key, value);
+        } else {
+            return (M) map.put(key, merge.apply(currentValue.get(), value));
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    static <K, V, M extends Map<K, V>> M put(M map, Tuple2<? extends K, ? extends V> entry) {
+        Objects.requireNonNull(entry, "entry is null");
+        return (M) map.put(entry._1, entry._2);
+    }
+
+    static <K, V, U extends V, M extends Map<K, V>> M put(M map, Tuple2<? extends K, U> entry,
+                                                          BiFunction<? super V, ? super U, ? extends V> merge) {
+        Objects.requireNonNull(merge, "the merge function is null");
+        final Option<V> currentValue = map.get(entry._1);
+        if (currentValue.isEmpty()) {
+            return put(map, entry);
+        } else {
+            return put(map, entry.map2(value -> merge.apply(currentValue.get(), value)));
+        }
+    }
+
+    static <K, V, M extends Map<K, V>> M removeAll(M map, OfEntries<K, V, M> ofEntries,
+                                                   BiPredicate<? super K, ? super V> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        return filter(map, ofEntries, predicate.negate());
+    }
+
+    static <K, V, M extends Map<K, V>> M removeKeys(M map, OfEntries<K, V, M> ofEntries,
+                                                    Predicate<? super K> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        return filterKeys(map, ofEntries, predicate.negate());
+    }
+
+    static <K, V, M extends Map<K, V>> M removeValues(M map, OfEntries<K, V, M> ofEntries,
+                                                      Predicate<? super V> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        return filterValues(map, ofEntries, predicate.negate());
+    }
+
+    @SuppressWarnings("unchecked")
+    static <K, V, M extends Map<K, V>> M replace(M map, Tuple2<K, V> currentElement, Tuple2<K, V> newElement) {
+        Objects.requireNonNull(currentElement, "currentElement is null");
+        Objects.requireNonNull(newElement, "newElement is null");
+        return (M) (map.containsKey(currentElement._1) ? map.remove(currentElement._1).put(newElement) : map);
+    }
+
+    static <K, V, M extends Map<K, V>> M replaceAll(M map, Tuple2<K, V> currentElement, Tuple2<K, V> newElement) {
+        return replace(map, currentElement, newElement);
+    }
+
+    static <K, V, M extends Map<K, V>> M scan(
+            M map, Supplier<M> emptySupplier, Tuple2<K, V> zero,
+            BiFunction<? super Tuple2<K, V>, ? super Tuple2<K, V>, ? extends Tuple2<K, V>> operation) {
+        Objects.requireNonNull(operation, "operation is null");
+        return Collections.scanLeft(map, zero, operation, emptySupplier.get(), Maps::put, Function.identity());
+    }
+
+    static <K, V, M extends Map<K, V>> Iterator<M> sliding(M map, OfEntries<K, V, M> ofEntries, int size) {
+        return sliding(map, ofEntries, size, 1);
+    }
+
+    static <K, V, M extends Map<K, V>> Iterator<M> sliding(M map, OfEntries<K, V, M> ofEntries, int size, int step) {
+        return map.iterator().sliding(size, step).map(ofEntries);
+    }
+
+    static <K, V, M extends Map<K, V>> Tuple2<M, M> span(M map, OfEntries<K, V, M> ofEntries,
+                                                         Predicate<? super Tuple2<K, V>> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        final Tuple2<Iterator<Tuple2<K, V>>, Iterator<Tuple2<K, V>>> t = map.iterator().span(predicate);
+        return Tuple.of(ofEntries.apply(t._1), ofEntries.apply(t._2));
+    }
+
+    @SuppressWarnings("unchecked")
+    static <K, V, M extends Map<K, V>> Option<M> tailOption(M map) {
+        return map.isEmpty() ? Option.none() : Option.some((M) map.tail());
+    }
+
+    static <K, V, M extends Map<K, V>> M take(M map, OfEntries<K, V, M> ofEntries, int n) {
+        if (n >= map.size()) {
+            return map;
+        } else {
+            return ofEntries.apply(map.iterator().take(n));
+        }
+    }
+
+    static <K, V, M extends Map<K, V>> M takeRight(M map, OfEntries<K, V, M> ofEntries, int n) {
+        if (n >= map.size()) {
+            return map;
+        } else {
+            return ofEntries.apply(map.iterator().takeRight(n));
+        }
+    }
+
+    static <K, V, M extends Map<K, V>> M takeUntil(M map, OfEntries<K, V, M> ofEntries,
+                                                   Predicate<? super Tuple2<K, V>> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        return takeWhile(map, ofEntries, predicate.negate());
+    }
+
+    static <K, V, M extends Map<K, V>> M takeWhile(M map, OfEntries<K, V, M> ofEntries,
+                                                   Predicate<? super Tuple2<K, V>> predicate) {
+        Objects.requireNonNull(predicate, "predicate is null");
+        final M taken = ofEntries.apply(map.iterator().takeWhile(predicate));
+        return taken.size() == map.size() ? map : taken;
+    }
+
+    @FunctionalInterface
+    interface OfEntries<K, V, M extends Map<K, V>> extends Function<Iterable<Tuple2<K, V>>, M> {
+    }
+}
diff --git a/javaslang/src/main/java/javaslang/collection/TreeMap.java b/javaslang/src/main/java/javaslang/collection/TreeMap.java
index 9e7c5360fe..228de5ec3c 100644
--- a/javaslang/src/main/java/javaslang/collection/TreeMap.java
+++ b/javaslang/src/main/java/javaslang/collection/TreeMap.java
@@ -29,7 +29,7 @@
  * @since 2.0.0
  */
 // DEV-NOTE: use entries.min().get() in favor of iterator().next(), it is faster!
-public final class TreeMap<K, V> extends AbstractMap<K, V, TreeMap<K, V>> implements Kind2<TreeMap<?, ?>, K, V>, SortedMap<K, V>, Serializable {
+public final class TreeMap<K, V> implements Kind2<TreeMap<?, ?>, K, V>, SortedMap<K, V>, Serializable {
 
     private static final long serialVersionUID = 1L;
 
@@ -392,16 +392,6 @@ public static <K, V> TreeMap<K, V> ofEntries(Comparator<? super K> keyComparator
         }
     }
 
-    @Override
-    TreeMap<K, V> createFromEntries(Iterable<? extends Tuple2<? extends K, ? extends V>> it) {
-        return createTreeMap(entries.comparator(), it);
-    }
-
-    @Override
-    TreeMap<K, V> emptyInstance() {
-        return isEmpty() ? this : new TreeMap<>(entries.emptyInstance());
-    }
-
     @Override
     public <K2, V2> TreeMap<K2, V2> bimap(Function<? super K, ? extends K2> keyMapper, Function<? super V, ? extends V2> valueMapper) {
         return bimap(naturalComparator(), keyMapper, valueMapper);
@@ -413,7 +403,7 @@ public <K2, V2> TreeMap<K2, V2> bimap(Comparator<? super K2> keyComparator,
         Objects.requireNonNull(keyMapper, "keyMapper is null");
         Objects.requireNonNull(valueMapper, "valueMapper is null");
         return createTreeMap(new EntryComparator<>(keyComparator),
-                             entries.iterator().map(entry -> Tuple.of(keyMapper.apply(entry._1), valueMapper.apply(entry._2))));
+                entries.iterator().map(entry -> Tuple.of(keyMapper.apply(entry._1), valueMapper.apply(entry._2))));
     }
 
     @Override
@@ -422,6 +412,61 @@ public boolean containsKey(K key) {
         return entries.contains(new Tuple2<>(key, ignored));
     }
 
+    @Override
+    public TreeMap<K, V> distinct() {
+        return Maps.distinct(this);
+    }
+
+    @Override
+    public TreeMap<K, V> distinctBy(Comparator<? super Tuple2<K, V>> comparator) {
+        return Maps.distinctBy(this, this::createFromEntries, comparator);
+    }
+
+    @Override
+    public <U> TreeMap<K, V> distinctBy(Function<? super Tuple2<K, V>, ? extends U> keyExtractor) {
+        return Maps.distinctBy(this, this::createFromEntries, keyExtractor);
+    }
+
+    @Override
+    public TreeMap<K, V> drop(int n) {
+        return Maps.drop(this, this::createFromEntries, this::emptyInstance, n);
+    }
+
+    @Override
+    public TreeMap<K, V> dropRight(int n) {
+        return Maps.dropRight(this, this::createFromEntries, this::emptyInstance, n);
+    }
+
+    @Override
+    public TreeMap<K, V> dropUntil(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.dropUntil(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public TreeMap<K, V> dropWhile(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.dropWhile(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public TreeMap<K, V> filter(BiPredicate<? super K, ? super V> predicate) {
+        return Maps.filter(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public TreeMap<K, V> filter(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.filter(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public TreeMap<K, V> filterKeys(Predicate<? super K> predicate) {
+        return Maps.filterKeys(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public TreeMap<K, V> filterValues(Predicate<? super V> predicate) {
+        return Maps.filterValues(this, this::createFromEntries, predicate);
+    }
+
     @Override
     public <K2, V2> TreeMap<K2, V2> flatMap(BiFunction<? super K, ? super V, ? extends Iterable<Tuple2<K2, V2>>> mapper) {
         return flatMap(naturalComparator(), mapper);
@@ -432,7 +477,7 @@ public <K2, V2> TreeMap<K2, V2> flatMap(Comparator<? super K2> keyComparator,
                                             BiFunction<? super K, ? super V, ? extends Iterable<Tuple2<K2, V2>>> mapper) {
         Objects.requireNonNull(mapper, "mapper is null");
         return createTreeMap(new EntryComparator<>(keyComparator),
-                             entries.iterator().flatMap(entry -> mapper.apply(entry._1, entry._2)));
+                entries.iterator().flatMap(entry -> mapper.apply(entry._1, entry._2)));
     }
 
     @Override
@@ -441,6 +486,16 @@ public Option<V> get(K key) {
         return entries.find(new Tuple2<>(key, ignored)).map(Tuple2::_2);
     }
 
+    @Override
+    public <C> Map<C, TreeMap<K, V>> groupBy(Function<? super Tuple2<K, V>, ? extends C> classifier) {
+        return Maps.groupBy(this, this::createFromEntries, classifier);
+    }
+
+    @Override
+    public Iterator<TreeMap<K, V>> grouped(int size) {
+        return Maps.grouped(this, this::createFromEntries, size);
+    }
+
     @Override
     public Tuple2<K, V> head() {
         if (isEmpty()) {
@@ -460,6 +515,11 @@ public TreeMap<K, V> init() {
         }
     }
 
+    @Override
+    public Option<TreeMap<K, V>> initOption() {
+        return Maps.initOption(this);
+    }
+
     @Override
     public boolean isEmpty() {
         return entries.isEmpty();
@@ -491,7 +551,7 @@ public <K2, V2> TreeMap<K2, V2> map(Comparator<? super K2> keyComparator,
                                         BiFunction<? super K, ? super V, Tuple2<K2, V2>> mapper) {
         Objects.requireNonNull(mapper, "mapper is null");
         return createTreeMap(new EntryComparator<>(keyComparator),
-                             entries.iterator().map(entry -> mapper.apply(entry._1, entry._2)));
+                entries.iterator().map(entry -> mapper.apply(entry._1, entry._2)));
     }
 
     @Override
@@ -512,11 +572,48 @@ public <W> TreeMap<K, W> mapValues(Function<? super V, ? extends W> valueMapper)
         return map(keyComparator(), (k, v) -> Tuple.of(k, valueMapper.apply(v)));
     }
 
+    @Override
+    public TreeMap<K, V> merge(Map<? extends K, ? extends V> that) {
+        return Maps.merge(this, this::createFromEntries, that);
+    }
+
+    @Override
+    public <U extends V> TreeMap<K, V> merge(Map<? extends K, U> that,
+                                             BiFunction<? super V, ? super U, ? extends V> collisionResolution) {
+        return Maps.merge(this, this::createFromEntries, that, collisionResolution);
+    }
+
+    @Override
+    public Tuple2<TreeMap<K, V>, TreeMap<K, V>> partition(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.partition(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public TreeMap<K, V> peek(Consumer<? super Tuple2<K, V>> action) {
+        return Maps.peek(this, action);
+    }
+
+    @Override
+    public <U extends V> TreeMap<K, V> put(K key, U value, BiFunction<? super V, ? super U, ? extends V> merge) {
+        return Maps.put(this, key, value, merge);
+    }
+
     @Override
     public TreeMap<K, V> put(K key, V value) {
         return new TreeMap<>(entries.insert(new Tuple2<>(key, value)));
     }
 
+    @Override
+    public TreeMap<K, V> put(Tuple2<? extends K, ? extends V> entry) {
+        return Maps.put(this, entry);
+    }
+
+    @Override
+    public <U extends V> TreeMap<K, V> put(Tuple2<? extends K, U> entry,
+                                           BiFunction<? super V, ? super U, ? extends V> merge) {
+        return Maps.put(this, entry, merge);
+    }
+
     @Override
     public TreeMap<K, V> remove(K key) {
         final V ignored = null;
@@ -528,6 +625,11 @@ public TreeMap<K, V> remove(K key) {
         }
     }
 
+    @Override
+    public TreeMap<K, V> removeAll(BiPredicate<? super K, ? super V> predicate) {
+        return Maps.removeAll(this, this::createFromEntries, predicate);
+    }
+
     @Override
     public TreeMap<K, V> removeAll(Iterable<? extends K> keys) {
         final V ignored = null;
@@ -545,6 +647,26 @@ public TreeMap<K, V> removeAll(Iterable<? extends K> keys) {
         }
     }
 
+    @Override
+    public TreeMap<K, V> removeKeys(Predicate<? super K> predicate) {
+        return Maps.removeKeys(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public TreeMap<K, V> removeValues(Predicate<? super V> predicate) {
+        return Maps.removeValues(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public TreeMap<K, V> replace(Tuple2<K, V> currentElement, Tuple2<K, V> newElement) {
+        return Maps.replace(this, currentElement, newElement);
+    }
+
+    @Override
+    public TreeMap<K, V> replaceAll(Tuple2<K, V> currentElement, Tuple2<K, V> newElement) {
+        return Maps.replaceAll(this, currentElement, newElement);
+    }
+
     @Override
     public TreeMap<K, V> retainAll(Iterable<? extends Tuple2<K, V>> elements) {
         Objects.requireNonNull(elements, "elements is null");
@@ -557,11 +679,33 @@ public TreeMap<K, V> retainAll(Iterable<? extends Tuple2<K, V>> elements) {
         return new TreeMap<>(tree);
     }
 
+    @Override
+    public TreeMap<K, V> scan(
+            Tuple2<K, V> zero,
+            BiFunction<? super Tuple2<K, V>, ? super Tuple2<K, V>, ? extends Tuple2<K, V>> operation) {
+        return Maps.scan(this, this::emptyInstance, zero, operation);
+    }
+
     @Override
     public int size() {
         return entries.size();
     }
 
+    @Override
+    public Iterator<TreeMap<K, V>> sliding(int size) {
+        return Maps.sliding(this, this::createFromEntries, size);
+    }
+
+    @Override
+    public Iterator<TreeMap<K, V>> sliding(int size, int step) {
+        return Maps.sliding(this, this::createFromEntries, size, step);
+    }
+
+    @Override
+    public Tuple2<TreeMap<K, V>, TreeMap<K, V>> span(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.span(this, this::createFromEntries, predicate);
+    }
+
     @Override
     public TreeMap<K, V> tail() {
         if (isEmpty()) {
@@ -572,6 +716,31 @@ public TreeMap<K, V> tail() {
         }
     }
 
+    @Override
+    public Option<TreeMap<K, V>> tailOption() {
+        return Maps.tailOption(this);
+    }
+
+    @Override
+    public TreeMap<K, V> take(int n) {
+        return Maps.take(this, this::createFromEntries, n);
+    }
+
+    @Override
+    public TreeMap<K, V> takeRight(int n) {
+        return Maps.takeRight(this, this::createFromEntries, n);
+    }
+
+    @Override
+    public TreeMap<K, V> takeUntil(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.takeUntil(this, this::createFromEntries, predicate);
+    }
+
+    @Override
+    public TreeMap<K, V> takeWhile(Predicate<? super Tuple2<K, V>> predicate) {
+        return Maps.takeWhile(this, this::createFromEntries, predicate);
+    }
+
     @Override
     public java.util.TreeMap<K, V> toJavaMap() {
         return toJavaMap(() -> new java.util.TreeMap<>(keyComparator()), t -> t);
@@ -598,8 +767,7 @@ private static <K, V> TreeMap<K, V> createTreeMap(Comparator<? super Tuple2<K, V
         for (Tuple2<? extends K, ? extends V> entry : entries) {
             tree = tree.insert((Tuple2<K, V>) entry);
         }
-        return tree.isEmpty() ? (TreeMap<K, V>) empty()
-                              : new TreeMap<>(tree);
+        return tree.isEmpty() ? (TreeMap<K, V>) empty() : new TreeMap<>(tree);
     }
 
     // -- Object
@@ -631,6 +799,14 @@ public String toString() {
         return mkString(stringPrefix() + "(", ", ", ")");
     }
 
+    private TreeMap<K, V> createFromEntries(Iterable<Tuple2<K, V>> tuples) {
+        return createTreeMap(entries.comparator(), tuples);
+    }
+
+    private TreeMap<K, V> emptyInstance() {
+        return isEmpty() ? this : new TreeMap<>(entries.emptyInstance());
+    }
+
     /**
      * Used to compare entries by key and store the keyComparator for later access.
      *
diff --git a/javaslang/src/test/java/outside_of_javaslang/IllegalAccessErrorTest.java b/javaslang/src/test/java/outside_of_javaslang/IllegalAccessErrorTest.java
new file mode 100644
index 0000000000..26d4be9893
--- /dev/null
+++ b/javaslang/src/test/java/outside_of_javaslang/IllegalAccessErrorTest.java
@@ -0,0 +1,26 @@
+/*     / \____  _    _  ____   ______  / \ ____  __    _______
+ *    /  /    \/ \  / \/    \ /  /\__\/  //    \/  \  //  /\__\   JΛVΛSLΛNG
+ *  _/  /  /\  \  \/  /  /\  \\__\\  \  //  /\  \ /\\/ \ /__\ \   Copyright 2014-2016 Javaslang, http://javaslang.io
+ * /___/\_/  \_/\____/\_/  \_/\__\/__/\__\_/  \_//  \__/\_____/   Licensed under the Apache License, Version 2.0
+ */
+package outside_of_javaslang;
+
+import javaslang.collection.Array;
+import javaslang.collection.HashMap;
+import org.junit.Test;
+
+import java.util.function.BiFunction;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class IllegalAccessErrorTest {
+
+    @Test
+    public void shouldNotThrowIllegalAccessErrorWhenUsingHashMapMergeMethodReference() {
+        final BiFunction<HashMap<String, String>, HashMap<String, String>, HashMap<String, String>> merge = HashMap::merge;
+        final HashMap<String, String> reduced = Array.of("a", "b", "c")
+                .map(t -> HashMap.of(t, t))
+                .reduce(merge);
+        assertThat(reduced).isEqualTo(HashMap.of("a", "a", "b", "b", "c", "c"));
+    }
+}