diff --git a/docs/language/api.rst b/docs/language/api.rst
index 67ef630..496caca 100644
--- a/docs/language/api.rst
+++ b/docs/language/api.rst
@@ -657,7 +657,7 @@ del
   => (setv test (list (range 10)))
   => test
   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
-  => (del (slice test 2 4)) ;; remove items from 2 to 4 excluded
+  => (del (cut test 2 4)) ;; remove items from 2 to 4 excluded
   => test
   [0, 1, 4, 5, 6, 7, 8, 9]
   => (setv dic {"foo" "bar"})
@@ -1243,35 +1243,35 @@ expression.
     {1, 3, 5}
 
 
-slice
+cut
 -----
 
-``slice`` can be used to take a subset of a list and create a new list from it.
-The form takes at least one parameter specifying the list to slice. Two
+``cut`` can be used to take a subset of a list and create a new list from it.
+The form takes at least one parameter specifying the list to cut. Two
 optional parameters can be used to give the start and end position of the
 subset. If they are not supplied, the default value of ``None`` will be used
 instead. The third optional parameter is used to control step between the elements.
 
-``slice`` follows the same rules as its Python counterpart. Negative indices are
+``cut`` follows the same rules as its Python counterpart. Negative indices are
 counted starting from the end of the list. Some example usage:
 
 .. code-block:: clj
 
     => (def collection (range 10))
 
-    => (slice collection)
+    => (cut collection)
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
-    => (slice collection 5)
+    => (cut collection 5)
     [5, 6, 7, 8, 9]
 
-    => (slice collection 2 8)
+    => (cut collection 2 8)
     [2, 3, 4, 5, 6, 7]
 
-    => (slice collection 2 8 2)
+    => (cut collection 2 8 2)
     [2, 4, 6]
 
-    => (slice collection -4 -2)
+    => (cut collection -4 -2)
     [6, 7]
 
 
diff --git a/docs/language/internals.rst b/docs/language/internals.rst
index cc25efb..faa69fb 100644
--- a/docs/language/internals.rst
+++ b/docs/language/internals.rst
@@ -184,7 +184,7 @@ expressions are made of Python lists wrapped in a
  - ``(cons something some-list)`` is ``((type some-list) (+ [something]
    some-list))`` (if ``some-list`` inherits from ``list``).
  - ``(get (cons a b) 0)`` is ``a``
- - ``(slice (cons a b) 1)`` is ``b``
+ - ``(cut (cons a b) 1)`` is ``b``
 
 Hy supports a dotted-list syntax, where ``'(a . b)`` means ``(cons 'a
 'b)`` and ``'(a b . c)`` means ``(cons 'a (cons 'b 'c))``. If the
diff --git a/eg/lxml/parse-tumblr.hy b/eg/lxml/parse-tumblr.hy
index ddbc426..dbc2db0 100644
--- a/eg/lxml/parse-tumblr.hy
+++ b/eg/lxml/parse-tumblr.hy
@@ -20,6 +20,6 @@
   (for [post (.xpath (get-rss-feed tumblr) "//item/title")]
     (print post.text)))
 
-(if (slice argv 2)
+(if (cut argv 2)
   (print-posts (get argv 2))
   (print-posts "this-plt-life"))
diff --git a/hy/compiler.py b/hy/compiler.py
index cd00530..f3ddb81 100644
--- a/hy/compiler.py
+++ b/hy/compiler.py
@@ -1314,9 +1314,9 @@ class HyASTCompiler(object):
             col_offset=expr.start_column,
             targets=del_targets)
 
-    @builds("slice")
+    @builds("cut")
     @checkargs(min=1, max=4)
-    def compile_slice_expression(self, expr):
+    def compile_cut_expression(self, expr):
         expr.pop(0)  # index
         val = self.compile(expr.pop(0))  # target
 
@@ -1600,7 +1600,7 @@ class HyASTCompiler(object):
 
                 # We then pass the other arguments to the function
                 expr[0] = HyExpression(
-                    [HySymbol("slice"), tempvar, HyInteger(1)]
+                    [HySymbol("cut"), tempvar, HyInteger(1)]
                 ).replace(expr[0])
 
         ret += self.compile(call)
diff --git a/hy/core/language.hy b/hy/core/language.hy
index 8557760..212dd77 100644
--- a/hy/core/language.hy
+++ b/hy/core/language.hy
@@ -416,7 +416,7 @@
   "Convert the given value to a string. Keyword special character will be stripped.
   String will be used as is. Even objects with the __name__ magic will work"
   (if (and (string? value) (value.startswith *keyword-prefix*))
-    (hyify (slice value 2))
+    (hyify (cut value 2))
     (if (string? value)
       (hyify value)
       (try
diff --git a/hy/core/macros.hy b/hy/core/macros.hy
index b0c06db..3f58683 100644
--- a/hy/core/macros.hy
+++ b/hy/core/macros.hy
@@ -57,7 +57,7 @@
 
 (defmacro cdr [thing]
   "Get all the elements of a thing, except the first"
-  `(slice ~thing 1))
+  `(cut ~thing 1))
 
 
 (defmacro cond [&rest branches]
@@ -104,7 +104,7 @@
    [(empty? args) `(do ~@body)]
    [(= (len args) 2)  `(for* [~@args] ~@body)]
    [true 
-    (let [[alist (slice args 0 nil 2)]]
+    (let [[alist (cut args 0 nil 2)]]
       `(for* [(, ~@alist) (genexpr (, ~@alist) [~@args])] ~@body))]))
 
 
@@ -175,7 +175,7 @@
 (defmacro defmacro/g! [name args &rest body]
   (let [[syms (list (distinct (filter (fn [x] (and (hasattr x "startswith") (.startswith x "g!"))) (flatten body))))]]
     `(defmacro ~name [~@args]
-       (let ~(HyList (map (fn [x] `[~x (gensym (slice '~x 2))]) syms))
+       (let ~(HyList (map (fn [x] `[~x (gensym (cut '~x 2))]) syms))
             ~@body))))
 
 
@@ -221,6 +221,6 @@
     ret))
 
 (defreader @ [expr]
-  (let [[decorators (slice expr nil -1)]
+  (let [[decorators (cut expr nil -1)]
         [fndef (get expr -1)]]
     `(with-decorator ~@decorators ~fndef)))
diff --git a/hy/core/shadow.hy b/hy/core/shadow.hy
index fed7d0f..b475e37 100644
--- a/hy/core/shadow.hy
+++ b/hy/core/shadow.hy
@@ -67,7 +67,7 @@
     (raise (TypeError "Need at least 2 arguments to compare"))
     (reduce operator.and_
             (list-comp (op x y)
-                       [(, x y) (zip args (slice args 1))]))))
+                       [(, x y) (zip args (cut args 1))]))))
 (defn < [&rest args]
   "Shadow < operator for when we need to import / map it against something"
   (comp-op operator.lt args))
diff --git a/tests/compilers/test_ast.py b/tests/compilers/test_ast.py
index 7ef5451..0931840 100644
--- a/tests/compilers/test_ast.py
+++ b/tests/compilers/test_ast.py
@@ -291,18 +291,18 @@ def test_ast_bad_get():
     cant_compile("(get 1)")
 
 
-def test_ast_good_slice():
-    "Make sure AST can compile valid slice"
-    can_compile("(slice x)")
-    can_compile("(slice x y)")
-    can_compile("(slice x y z)")
-    can_compile("(slice x y z t)")
+def test_ast_good_cut():
+    "Make sure AST can compile valid cut"
+    can_compile("(cut x)")
+    can_compile("(cut x y)")
+    can_compile("(cut x y z)")
+    can_compile("(cut x y z t)")
 
 
-def test_ast_bad_slice():
-    "Make sure AST can't compile invalid slice"
-    cant_compile("(slice)")
-    cant_compile("(slice 1 2 3 4 5)")
+def test_ast_bad_cut():
+    "Make sure AST can't compile invalid cut"
+    cant_compile("(cut)")
+    cant_compile("(cut 1 2 3 4 5)")
 
 
 def test_ast_good_take():
diff --git a/tests/native_tests/language.hy b/tests/native_tests/language.hy
index 352ecf5..d70410a 100644
--- a/tests/native_tests/language.hy
+++ b/tests/native_tests/language.hy
@@ -536,11 +536,11 @@
   (assert (= (car [1 2 3 4 5]) 1)))
 
 
-(defn test-slice []
-  "NATIVE: test slice"
-  (assert (= (slice [1 2 3 4 5] 1) [2 3 4 5]))
-  (assert (= (slice [1 2 3 4 5] 1 3) [2 3]))
-  (assert (= (slice [1 2 3 4 5]) [1 2 3 4 5])))
+(defn test-cut []
+  "NATIVE: test cut"
+  (assert (= (cut [1 2 3 4 5] 1) [2 3 4 5]))
+  (assert (= (cut [1 2 3 4 5] 1 3) [2 3]))
+  (assert (= (cut [1 2 3 4 5]) [1 2 3 4 5])))
 
 
 (defn test-take []