diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4868a383a1..51948ec6cf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 ## 0.7.0 (unreleased)
 
-- Updated Polars to 0.33.2
+- Updated Polars to 0.34.1
 - Added `!` for `Expr`
 - Added `Config` module
 - Added `none?` method to `Series`
diff --git a/Cargo.lock b/Cargo.lock
index a1762b3045..79308bb025 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,15 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "addr2line"
+version = "0.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
+dependencies = [
+ "gimli",
+]
+
 [[package]]
 name = "adler"
 version = "1.0.2"
@@ -16,14 +25,15 @@ checksum = "aae1277d39aeec15cb388266ecc24b11c80469deae6067e17a1a7aa9e5c1f234"
 
 [[package]]
 name = "ahash"
-version = "0.8.3"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f"
+checksum = "cd7d5a2cecb58716e47d67d5703a249964b14c7be1ec3cad3affc295b2d1c35d"
 dependencies = [
  "cfg-if",
  "getrandom",
  "once_cell",
  "version_check",
+ "zerocopy",
 ]
 
 [[package]]
@@ -96,42 +106,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "arrow2"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "963fef509b757bcbbf9e5ffa23bcb345614d99f4f6f531f97417b27b8604d389"
-dependencies = [
- "ahash",
- "arrow-format",
- "avro-schema",
- "base64",
- "bytemuck",
- "chrono",
- "chrono-tz",
- "dyn-clone",
- "either",
- "ethnum",
- "fallible-streaming-iterator",
- "foreign_vec",
- "futures",
- "getrandom",
- "hash_hasher",
- "hashbrown 0.14.0",
- "lexical-core",
- "lz4",
- "multiversion",
- "num-traits",
- "parquet2",
- "regex",
- "regex-syntax",
- "rustc_version",
- "simdutf8",
- "streaming-iterator",
- "strength_reduce",
- "zstd",
-]
-
 [[package]]
 name = "async-stream"
 version = "0.3.5"
@@ -194,6 +168,21 @@ dependencies = [
  "snap",
 ]
 
+[[package]]
+name = "backtrace"
+version = "0.3.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837"
+dependencies = [
+ "addr2line",
+ "cc",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+]
+
 [[package]]
 name = "base64"
 version = "0.21.4"
@@ -656,6 +645,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "gimli"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6fb8d784f27acf97159b40fc4db5ecd8aa23b9ad5ef69cdd136d3bc80665f0c0"
+
 [[package]]
 name = "glob"
 version = "0.3.1"
@@ -672,12 +667,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "hash_hasher"
-version = "2.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74721d007512d0cb3338cd20f0654ac913920061a4c4d0d8708edb3f2a698c0c"
-
 [[package]]
 name = "hashbrown"
 version = "0.13.2"
@@ -1145,6 +1134,15 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "object"
+version = "0.32.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cf5f9dd3933bd50a9e1f149ec995f39ae2c496d31fd772c1fd45ebc27e902b0"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.18.0"
@@ -1199,7 +1197,8 @@ dependencies = [
  "seq-macro",
  "snap",
  "streaming-decompression",
- "zstd",
+ "xxhash-rust",
+ "zstd 0.12.4",
 ]
 
 [[package]]
@@ -1217,6 +1216,12 @@ version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
 
+[[package]]
+name = "percent-encoding"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94"
+
 [[package]]
 name = "phf"
 version = "0.11.2"
@@ -1292,7 +1297,7 @@ dependencies = [
  "jemallocator",
  "magnus",
  "mimalloc",
- "polars 0.33.2",
+ "polars 0.34.1",
  "polars-core",
  "serde_json",
  "smartstring",
@@ -1300,9 +1305,9 @@ dependencies = [
 
 [[package]]
 name = "polars"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3030de163b9ff2c9dac9a12dcb9be25cc0f2bc7c8e7cd2e4b2592ebed458ce6a"
+checksum = "ed842e5aad34e81b6904f68fa57196341bb7eeb84e04f5f71a6d4f50609a1fc1"
 dependencies = [
  "getrandom",
  "polars-core",
@@ -1316,33 +1321,49 @@ dependencies = [
 
 [[package]]
 name = "polars-arrow"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35cd38a64fb389fd990e4efd433a36331c995c981d353bfef83b5de4d87f1828"
+checksum = "fc02e90fbdc3dccc0fb61becb6c63f57a2660f715bbd220e6f689ed5691915b6"
 dependencies = [
- "arrow2",
+ "ahash",
+ "arrow-format",
  "atoi",
+ "avro-schema",
+ "base64",
+ "bytemuck",
  "chrono",
  "chrono-tz",
+ "dyn-clone",
+ "either",
  "ethnum",
+ "fallible-streaming-iterator",
+ "foreign_vec",
+ "futures",
+ "getrandom",
  "hashbrown 0.14.0",
+ "lexical-core",
+ "lz4",
  "multiversion",
  "num-traits",
+ "parquet2",
  "polars-error",
+ "rustc_version",
  "serde",
- "thiserror",
- "version_check",
+ "simdutf8",
+ "streaming-iterator",
+ "strength_reduce",
+ "zstd 0.13.0",
 ]
 
 [[package]]
 name = "polars-core"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08367c014c07fa8f141680e024f926cab3a1fe839605a8fcf2223647eb45ca71"
+checksum = "e3fc406dbfef1e83f651b34e5a5525b63303f062b74cc8816a36d6432e487c3d"
 dependencies = [
  "ahash",
- "arrow2",
  "bitflags 2.4.0",
+ "bytemuck",
  "chrono",
  "chrono-tz",
  "comfy-table",
@@ -1370,34 +1391,40 @@ dependencies = [
 
 [[package]]
 name = "polars-error"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b20a09651a299979354945819dc2ce017964b80b916954e9d2ce39002a5f949"
+checksum = "cc9233939f0cfaf8bf91c18044d04f88cdc152448b142e7fd55493e84adfe6b1"
 dependencies = [
- "arrow2",
+ "arrow-format",
+ "avro-schema",
+ "parquet2",
  "regex",
+ "simdutf8",
  "thiserror",
 ]
 
 [[package]]
 name = "polars-io"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88cf4a89c18a90ac20dfbcdfd19ab50ad4ac5a76fc7bb775d3c28bb738cf1f34"
+checksum = "6ae894c0ce199b2a7a02cfb59bdd70e0a21baac2923ca4fe106b4afdfe2d65b5"
 dependencies = [
  "ahash",
- "arrow2",
+ "async-trait",
  "bytes",
  "chrono",
  "chrono-tz",
  "fast-float",
+ "futures",
  "home",
+ "itoa",
  "lexical",
  "lexical-core",
  "memchr",
  "memmap2",
  "num-traits",
  "once_cell",
+ "percent-encoding",
  "polars-arrow",
  "polars-core",
  "polars-error",
@@ -1406,35 +1433,42 @@ dependencies = [
  "polars-utils",
  "rayon",
  "regex",
+ "ryu",
  "serde",
  "serde_json",
  "simd-json",
  "simdutf8",
+ "smartstring",
+ "tokio",
+ "tokio-util",
 ]
 
 [[package]]
 name = "polars-json"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6d5666176d681706aef5a06a57597c83391948b3d958f9fbe9b4cf016527eb8"
+checksum = "45f27c57f7a7c0c2156a116388710f756804d6b523afde239b394786d6bb7e4e"
 dependencies = [
  "ahash",
- "arrow2",
+ "chrono",
  "fallible-streaming-iterator",
  "hashbrown 0.14.0",
  "indexmap",
+ "itoa",
  "num-traits",
  "polars-arrow",
  "polars-error",
  "polars-utils",
+ "ryu",
  "simd-json",
+ "streaming-iterator",
 ]
 
 [[package]]
 name = "polars-lazy"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5110eab438848c981cc5f541fbc5b21bb263fd707000b4715233074fb2630fcf"
+checksum = "45f1bbb176e3fcd1130a68307727def479b48b1b6082cdc67fb605e45218a065"
 dependencies = [
  "ahash",
  "bitflags 2.4.0",
@@ -1456,24 +1490,31 @@ dependencies = [
 
 [[package]]
 name = "polars-ops"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7740d7bc4c2ca08044f9ef599638e116fdd7d687e80d1974b698e390c6ce4252"
+checksum = "2f9af534f705acaf83515a64ba88f208f6f800b5c47939fec1b8b26c1d401b15"
 dependencies = [
+ "ahash",
  "argminmax",
- "arrow2",
  "base64",
+ "bytemuck",
  "chrono",
  "chrono-tz",
  "either",
+ "hashbrown 0.14.0",
  "hex",
  "indexmap",
  "jsonpath_lib",
  "memchr",
+ "num-traits",
  "polars-arrow",
  "polars-core",
+ "polars-error",
  "polars-json",
  "polars-utils",
+ "rand",
+ "rand_distr",
+ "rayon",
  "regex",
  "serde",
  "serde_json",
@@ -1483,9 +1524,9 @@ dependencies = [
 
 [[package]]
 name = "polars-pipe"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f30c5e77c5594ddc958a46fe2e021da2feba9c94e767e1d798bd82ac5a33c3b"
+checksum = "3c361a437ad24882ee47210e74a1ecdf83c211a3e6a7a1ae3fc1a9aa8a4c57cd"
 dependencies = [
  "crossbeam-channel",
  "crossbeam-queue",
@@ -1506,15 +1547,16 @@ dependencies = [
 
 [[package]]
 name = "polars-plan"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "678cbeb730e29e50f0f8d844102d15454fc6113a74c667eab046c0e4a4322a9e"
+checksum = "c886b06d95ba37a3342a891f2ded8c779b8b9375f6648648624e3d04e753e22b"
 dependencies = [
  "ahash",
- "arrow2",
+ "bytemuck",
  "chrono",
  "chrono-tz",
  "once_cell",
+ "percent-encoding",
  "polars-arrow",
  "polars-core",
  "polars-io",
@@ -1531,25 +1573,27 @@ dependencies = [
 
 [[package]]
 name = "polars-row"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c52ef8885b9d13f848839594fbab21ad79fc63f7e11c19cdc2cfe9bb03c313ac"
+checksum = "58b22c6535db871c2a8919a0b5ade6668bb068aaedc99c8e2523f40163ef9903"
 dependencies = [
- "arrow2",
+ "polars-arrow",
  "polars-error",
  "polars-utils",
 ]
 
 [[package]]
 name = "polars-sql"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d716855267e3516f722287f68cf10e650e33f7197df83a79e680602471456fc"
+checksum = "9a0e7d72e0a918b12f3eeb8ff250d927c31dcf2beaabd96f5a5b955d69577912"
 dependencies = [
  "polars-arrow",
  "polars-core",
+ "polars-error",
  "polars-lazy",
  "polars-plan",
+ "rand",
  "serde",
  "serde_json",
  "sqlparser",
@@ -1557,11 +1601,10 @@ dependencies = [
 
 [[package]]
 name = "polars-time"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb75a24f11b55a400b52dc19a2a3e949aaaa46a911f99496de4485b1127063"
+checksum = "441618b303021a5f9367658d88d9ab2734cf643ac957126dab56c4447c80bbb0"
 dependencies = [
- "arrow2",
  "atoi",
  "chrono",
  "chrono-tz",
@@ -1569,6 +1612,7 @@ dependencies = [
  "once_cell",
  "polars-arrow",
  "polars-core",
+ "polars-error",
  "polars-ops",
  "polars-utils",
  "regex",
@@ -1578,9 +1622,9 @@ dependencies = [
 
 [[package]]
 name = "polars-utils"
-version = "0.33.2"
+version = "0.34.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a4a5e743509096322cad39104d56e329fe2748483a3354a0f0c354724f3cef6"
+checksum = "e40876670842ec450eface74aa9391ae2fff5e8934fbfc7a7b10051c7f79023d"
 dependencies = [
  "ahash",
  "bytemuck",
@@ -1660,9 +1704,9 @@ dependencies = [
 
 [[package]]
 name = "rayon"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
+checksum = "9c27db03db7734835b3f53954b534c91069375ce6ccaa2e065441e07d9b6cdb1"
 dependencies = [
  "either",
  "rayon-core",
@@ -1670,14 +1714,12 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.11.0"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
+checksum = "5ce3fb6ad83f861aac485e76e1985cd109d9a3713802152be56c3b1f0e0658ed"
 dependencies = [
- "crossbeam-channel",
  "crossbeam-deque",
  "crossbeam-utils",
- "num_cpus",
 ]
 
 [[package]]
@@ -1754,6 +1796,12 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3582f63211428f83597b51b2ddb88e2a91a9d52d12831f9d08f5e624e8977422"
 
+[[package]]
+name = "rustc-demangle"
+version = "0.1.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
+
 [[package]]
 name = "rustc-hash"
 version = "1.1.0"
@@ -1875,9 +1923,9 @@ dependencies = [
 
 [[package]]
 name = "simd-json"
-version = "0.10.7"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80ea1dfc2c400965867fc4ddd6f502572be2de2074b39f90984ed15fbdbdd8eb"
+checksum = "f0f07a84c7456b901b8dd2c1d44caca8b0fd2c2616206ee5acc9d9da61e8d9ec"
 dependencies = [
  "ahash",
  "getrandom",
@@ -1935,11 +1983,21 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5e9f0ab6ef7eb7353d9119c170a436d1bf248eea575ac42d19d12f4e34130831"
 
+[[package]]
+name = "socket2"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4031e820eb552adee9295814c0ced9e5cf38ddf1e8b7d566d6de8e2538ea989e"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
 [[package]]
 name = "sqlparser"
-version = "0.36.1"
+version = "0.38.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2eaa1e88e78d2c2460d78b7dc3f0c08dbb606ab4222f9aff36f420d36e307d87"
+checksum = "0272b7bb0a225320170c99901b4b5fb3a4384e255a7f2cc228f61e2ba3893e75"
 dependencies = [
  "log",
 ]
@@ -2065,6 +2123,35 @@ dependencies = [
  "syn 2.0.36",
 ]
 
+[[package]]
+name = "tokio"
+version = "1.33.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4f38200e3ef7995e5ef13baec2f432a6da0aa9ac495b2c0e8f3b7eec2c92d653"
+dependencies = [
+ "backtrace",
+ "bytes",
+ "libc",
+ "mio",
+ "num_cpus",
+ "pin-project-lite",
+ "socket2",
+ "windows-sys",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d68074620f57a0b21594d9735eb2e98ab38b17f80d3fcb189fca266771ca60d"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.12"
@@ -2258,13 +2345,42 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9828b178da53440fa9c766a3d2f73f7cf5d0ac1fe3980c1e5018d899fd19e07b"
 
+[[package]]
+name = "zerocopy"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8db0ac2df3d060f81ec0380ccc5b71c2a7c092cfced671feeee1320e95559c87"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b6093bc6d5265ff40b479c834cdd25d8e20784781a2a29a8106327393d0a9ff"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.36",
+]
+
 [[package]]
 name = "zstd"
 version = "0.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a27595e173641171fc74a1232b7b1c7a7cb6e18222c11e9dfb9888fa424c53c"
 dependencies = [
- "zstd-safe",
+ "zstd-safe 6.0.6",
+]
+
+[[package]]
+name = "zstd"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bffb3309596d527cfcba7dfc6ed6052f1d39dfbd7c867aa2e865e4a449c10110"
+dependencies = [
+ "zstd-safe 7.0.0",
 ]
 
 [[package]]
@@ -2277,6 +2393,15 @@ dependencies = [
  "zstd-sys",
 ]
 
+[[package]]
+name = "zstd-safe"
+version = "7.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43747c7422e2924c11144d5229878b98180ef8b06cca4ab5af37afc8a8d8ea3e"
+dependencies = [
+ "zstd-sys",
+]
+
 [[package]]
 name = "zstd-sys"
 version = "2.0.8+zstd.1.5.5"
diff --git a/ext/polars/Cargo.toml b/ext/polars/Cargo.toml
index af9df8cb7a..292c2a2c8f 100644
--- a/ext/polars/Cargo.toml
+++ b/ext/polars/Cargo.toml
@@ -15,12 +15,12 @@ ahash = "0.8"
 chrono = "0.4"
 either = "1.8"
 magnus = "0.6"
-polars-core = "0.33.2"
+polars-core = "0.34.1"
 serde_json = "1"
 smartstring = "1"
 
 [dependencies.polars]
-version = "0.33.2"
+version = "0.34.1"
 features = [
     "abs",
     "approx_unique",
@@ -65,6 +65,7 @@ features = [
     "parquet",
     "partition_by",
     "pct_change",
+    "peaks",
     "performant",
     "pivot",
     "product",
@@ -83,7 +84,7 @@ features = [
     "sign",
     "string_encoding",
     "string_from_radix",
-    "string_justify",
+    "string_pad",
     "strings",
     "timezones",
     "to_dummies",
diff --git a/ext/polars/src/batched_csv.rs b/ext/polars/src/batched_csv.rs
index 4fcb963ecc..442399dc16 100644
--- a/ext/polars/src/batched_csv.rs
+++ b/ext/polars/src/batched_csv.rs
@@ -31,7 +31,7 @@ impl RbBatchedCsv {
         let n_rows = Option::<usize>::try_convert(arguments[4])?;
         let skip_rows = usize::try_convert(arguments[5])?;
         let projection = Option::<Vec<usize>>::try_convert(arguments[6])?;
-        let sep = String::try_convert(arguments[7])?;
+        let separator = String::try_convert(arguments[7])?;
         let rechunk = bool::try_convert(arguments[8])?;
         let columns = Option::<Vec<String>>::try_convert(arguments[9])?;
         let encoding = Wrap::<CsvEncoding>::try_convert(arguments[10])?;
@@ -90,7 +90,7 @@ impl RbBatchedCsv {
             .infer_schema(infer_schema_length)
             .has_header(has_header)
             .with_n_rows(n_rows)
-            .with_delimiter(sep.as_bytes()[0])
+            .with_separator(separator.as_bytes()[0])
             .with_skip_rows(skip_rows)
             .with_ignore_errors(ignore_errors)
             .with_projection(projection)
diff --git a/ext/polars/src/conversion.rs b/ext/polars/src/conversion.rs
index 250b7d9c81..b935ef3779 100644
--- a/ext/polars/src/conversion.rs
+++ b/ext/polars/src/conversion.rs
@@ -14,6 +14,7 @@ use polars::frame::NullStrategy;
 use polars::io::avro::AvroCompression;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
+use polars_core::utils::arrow::util::total_ord::TotalEq;
 use smartstring::alias::String as SmartString;
 
 use crate::object::OBJECT_NAME;
@@ -655,6 +656,12 @@ impl PartialEq for ObjectValue {
     }
 }
 
+impl TotalEq for ObjectValue {
+    fn tot_eq(&self, other: &Self) -> bool {
+        self == other
+    }
+}
+
 impl Display for ObjectValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self.to_object())
@@ -900,6 +907,22 @@ impl TryConvert for Wrap<JoinType> {
     }
 }
 
+impl TryConvert for Wrap<Label> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "left" => Label::Left,
+            "right" => Label::Right,
+            "datapoint" => Label::DataPoint,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "`label` must be one of {{'left', 'right', 'datapoint'}}, got {v}",
+                )))
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
 impl TryConvert for Wrap<ListToStructWidthStrategy> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match String::try_convert(ob)?.as_str() {
diff --git a/ext/polars/src/dataframe.rs b/ext/polars/src/dataframe.rs
index 7e68fb859b..ceca934e61 100644
--- a/ext/polars/src/dataframe.rs
+++ b/ext/polars/src/dataframe.rs
@@ -110,7 +110,7 @@ impl RbDataFrame {
         let n_rows = Option::<usize>::try_convert(arguments[5])?;
         let skip_rows = usize::try_convert(arguments[6])?;
         let projection = Option::<Vec<usize>>::try_convert(arguments[7])?;
-        let sep = String::try_convert(arguments[8])?;
+        let separator = String::try_convert(arguments[8])?;
         let rechunk = bool::try_convert(arguments[9])?;
         let columns = Option::<Vec<String>>::try_convert(arguments[10])?;
         let encoding = Wrap::<CsvEncoding>::try_convert(arguments[11])?;
@@ -168,7 +168,7 @@ impl RbDataFrame {
             .infer_schema(infer_schema_length)
             .has_header(has_header)
             .with_n_rows(n_rows)
-            .with_delimiter(sep.as_bytes()[0])
+            .with_separator(separator.as_bytes()[0])
             .with_skip_rows(skip_rows)
             .with_ignore_errors(ignore_errors)
             .with_projection(projection)
@@ -399,8 +399,8 @@ impl RbDataFrame {
         &self,
         rb_f: Value,
         has_header: bool,
-        sep: u8,
-        quote: u8,
+        separator: u8,
+        quote_char: u8,
         batch_size: usize,
         datetime_format: Option<String>,
         date_format: Option<String>,
@@ -415,8 +415,8 @@ impl RbDataFrame {
             // no need for a buffered writer, because the csv writer does internal buffering
             CsvWriter::new(f)
                 .has_header(has_header)
-                .with_delimiter(sep)
-                .with_quoting_char(quote)
+                .with_separator(separator)
+                .with_quote_char(quote_char)
                 .with_batch_size(batch_size)
                 .with_datetime_format(datetime_format)
                 .with_date_format(date_format)
@@ -429,8 +429,8 @@ impl RbDataFrame {
             let mut buf = Cursor::new(Vec::new());
             CsvWriter::new(&mut buf)
                 .has_header(has_header)
-                .with_delimiter(sep)
-                .with_quoting_char(quote)
+                .with_separator(separator)
+                .with_quote_char(quote_char)
                 .with_batch_size(batch_size)
                 .with_datetime_format(datetime_format)
                 .with_date_format(date_format)
@@ -607,7 +607,7 @@ impl RbDataFrame {
 
     pub fn sample_n(
         &self,
-        n: usize,
+        n: &RbSeries,
         with_replacement: bool,
         shuffle: bool,
         seed: Option<u64>,
@@ -615,14 +615,14 @@ impl RbDataFrame {
         let df = self
             .df
             .borrow()
-            .sample_n(n, with_replacement, shuffle, seed)
+            .sample_n(&n.series.borrow(), with_replacement, shuffle, seed)
             .map_err(RbPolarsErr::from)?;
         Ok(df.into())
     }
 
     pub fn sample_frac(
         &self,
-        frac: f64,
+        frac: &RbSeries,
         with_replacement: bool,
         shuffle: bool,
         seed: Option<u64>,
@@ -630,7 +630,7 @@ impl RbDataFrame {
         let df = self
             .df
             .borrow()
-            .sample_frac(frac, with_replacement, shuffle, seed)
+            .sample_frac(&frac.series.borrow(), with_replacement, shuffle, seed)
             .map_err(RbPolarsErr::from)?;
         Ok(df.into())
     }
diff --git a/ext/polars/src/error.rs b/ext/polars/src/error.rs
index dffdb4c1e8..f9f0bcf7b0 100644
--- a/ext/polars/src/error.rs
+++ b/ext/polars/src/error.rs
@@ -1,6 +1,5 @@
 use magnus::exception;
 use magnus::Error;
-use polars::error::ArrowError;
 use polars::prelude::PolarsError;
 
 pub struct RbPolarsErr {}
@@ -11,10 +10,6 @@ impl RbPolarsErr {
         Error::new(exception::runtime_error(), e.to_string())
     }
 
-    pub fn arrow(e: ArrowError) -> Error {
-        Error::new(exception::runtime_error(), e.to_string())
-    }
-
     pub fn io(e: std::io::Error) -> Error {
         Error::new(exception::runtime_error(), e.to_string())
     }
diff --git a/ext/polars/src/expr/datetime.rs b/ext/polars/src/expr/datetime.rs
index 53ff787cb8..d63c3b2c55 100644
--- a/ext/polars/src/expr/datetime.rs
+++ b/ext/polars/src/expr/datetime.rs
@@ -45,11 +45,11 @@ impl RbExpr {
             .into()
     }
 
-    pub fn dt_truncate(&self, every: String, offset: String, ambiguous: &Self) -> Self {
+    pub fn dt_truncate(&self, every: &Self, offset: String, ambiguous: &Self) -> Self {
         self.inner
             .clone()
             .dt()
-            .truncate(TruncateOptions { every, offset }, ambiguous.inner.clone())
+            .truncate(every.inner.clone(), offset, ambiguous.inner.clone())
             .into()
     }
 
@@ -61,8 +61,12 @@ impl RbExpr {
         self.inner.clone().dt().month_end().into()
     }
 
-    pub fn dt_round(&self, every: String, offset: String) -> Self {
-        self.inner.clone().dt().round(&every, &offset).into()
+    pub fn dt_round(&self, every: String, offset: String, ambiguous: &Self) -> Self {
+        self.inner
+            .clone()
+            .dt()
+            .round(&every, &offset, ambiguous.inner.clone())
+            .into()
     }
 
     pub fn dt_combine(&self, time: &Self, time_unit: Wrap<TimeUnit>) -> Self {
diff --git a/ext/polars/src/expr/general.rs b/ext/polars/src/expr/general.rs
index ae4a5d327a..f7a089e3e8 100644
--- a/ext/polars/src/expr/general.rs
+++ b/ext/polars/src/expr/general.rs
@@ -1,4 +1,4 @@
-use magnus::{block::Proc, prelude::*, value::Opaque, IntoValue, RArray, Ruby, Value};
+use magnus::{prelude::*, value::Opaque, IntoValue, RArray, Ruby, Value};
 use polars::lazy::dsl;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
@@ -219,12 +219,20 @@ impl RbExpr {
             .into()
     }
 
-    pub fn top_k(&self, k: usize) -> Self {
-        self.inner.clone().top_k(k).into()
+    pub fn top_k(&self, k: &Self) -> Self {
+        self.inner.clone().top_k(k.inner.clone()).into()
     }
 
-    pub fn bottom_k(&self, k: usize) -> Self {
-        self.inner.clone().bottom_k(k).into()
+    pub fn bottom_k(&self, k: &Self) -> Self {
+        self.inner.clone().bottom_k(k.inner.clone()).into()
+    }
+
+    pub fn peak_min(&self) -> Self {
+        self.inner.clone().peak_min().into()
+    }
+
+    pub fn peak_max(&self) -> Self {
+        self.inner.clone().peak_max().into()
     }
 
     pub fn arg_max(&self) -> Self {
@@ -390,20 +398,15 @@ impl RbExpr {
         self.clone().inner.ceil().into()
     }
 
-    pub fn clip(&self, min: Value, max: Value) -> Self {
-        let min = Wrap::<AnyValue>::try_convert(min).unwrap().0;
-        let max = Wrap::<AnyValue>::try_convert(max).unwrap().0;
-        self.clone().inner.clip(min, max).into()
-    }
-
-    pub fn clip_min(&self, min: Value) -> Self {
-        let min = Wrap::<AnyValue>::try_convert(min).unwrap().0;
-        self.clone().inner.clip_min(min).into()
-    }
-
-    pub fn clip_max(&self, max: Value) -> Self {
-        let max = Wrap::<AnyValue>::try_convert(max).unwrap().0;
-        self.clone().inner.clip_max(max).into()
+    pub fn clip(&self, min: Option<&Self>, max: Option<&Self>) -> Self {
+        let expr = self.inner.clone();
+        let out = match (min, max) {
+            (Some(min), Some(max)) => expr.clip(min.inner.clone(), max.inner.clone()),
+            (Some(min), None) => expr.clip_min(min.inner.clone()),
+            (None, Some(max)) => expr.clip_max(max.inner.clone()),
+            (None, None) => expr,
+        };
+        out.into()
     }
 
     pub fn abs(&self) -> Self {
@@ -544,35 +547,6 @@ impl RbExpr {
         self.inner.clone().mode().into()
     }
 
-    pub fn keep_name(&self) -> Self {
-        self.inner.clone().keep_name().into()
-    }
-
-    pub fn prefix(&self, prefix: String) -> Self {
-        self.inner.clone().prefix(&prefix).into()
-    }
-
-    pub fn suffix(&self, suffix: String) -> Self {
-        self.inner.clone().suffix(&suffix).into()
-    }
-
-    pub fn map_alias(&self, lambda: Proc) -> Self {
-        let lambda = Opaque::from(lambda);
-        self.inner
-            .clone()
-            .map_alias(move |name| {
-                let lambda = Ruby::get().unwrap().get_inner(lambda);
-                let out = lambda.call::<_, String>((name,));
-                match out {
-                    Ok(out) => Ok(out),
-                    Err(e) => Err(PolarsError::ComputeError(
-                        format!("Ruby function in 'map_alias' produced an error: {}.", e).into(),
-                    )),
-                }
-            })
-            .into()
-    }
-
     pub fn exclude(&self, columns: Vec<String>) -> Self {
         self.inner.clone().exclude(columns).into()
     }
@@ -608,8 +582,8 @@ impl RbExpr {
         self.inner.clone().diff(n, null_behavior.0).into()
     }
 
-    pub fn pct_change(&self, n: i64) -> Self {
-        self.inner.clone().pct_change(n).into()
+    pub fn pct_change(&self, n: &Self) -> Self {
+        self.inner.clone().pct_change(n.inner.clone()).into()
     }
 
     pub fn skew(&self, bias: bool) -> Self {
@@ -645,27 +619,27 @@ impl RbExpr {
 
     pub fn sample_n(
         &self,
-        n: usize,
+        n: &Self,
         with_replacement: bool,
         shuffle: bool,
         seed: Option<u64>,
     ) -> Self {
         self.inner
             .clone()
-            .sample_n(n, with_replacement, shuffle, seed)
+            .sample_n(n.inner.clone(), with_replacement, shuffle, seed)
             .into()
     }
 
     pub fn sample_frac(
         &self,
-        frac: f64,
+        frac: &Self,
         with_replacement: bool,
         shuffle: bool,
         seed: Option<u64>,
     ) -> Self {
         self.inner
             .clone()
-            .sample_frac(frac, with_replacement, shuffle, seed)
+            .sample_frac(frac.inner.clone(), with_replacement, shuffle, seed)
             .into()
     }
 
diff --git a/ext/polars/src/expr/list.rs b/ext/polars/src/expr/list.rs
index 26c84d2106..09933d1b91 100644
--- a/ext/polars/src/expr/list.rs
+++ b/ext/polars/src/expr/list.rs
@@ -47,12 +47,16 @@ impl RbExpr {
         self.inner.clone().list().get(index.inner.clone()).into()
     }
 
-    pub fn list_join(&self, separator: String) -> Self {
-        self.inner.clone().list().join(&separator).into()
+    pub fn list_join(&self, separator: &RbExpr) -> Self {
+        self.inner
+            .clone()
+            .list()
+            .join(separator.inner.clone())
+            .into()
     }
 
-    pub fn list_lengths(&self) -> Self {
-        self.inner.clone().list().lengths().into()
+    pub fn list_len(&self) -> Self {
+        self.inner.clone().list().len().into()
     }
 
     pub fn list_max(&self) -> Self {
@@ -76,8 +80,12 @@ impl RbExpr {
         self.inner.clone().list().reverse().into()
     }
 
-    pub fn list_shift(&self, periods: i64) -> Self {
-        self.inner.clone().list().shift(periods).into()
+    pub fn list_shift(&self, periods: &RbExpr) -> Self {
+        self.inner
+            .clone()
+            .list()
+            .shift(periods.inner.clone())
+            .into()
     }
 
     pub fn list_slice(&self, offset: &RbExpr, length: Option<&RbExpr>) -> Self {
diff --git a/ext/polars/src/expr/mod.rs b/ext/polars/src/expr/mod.rs
index ec2d76cb44..161ca36d17 100644
--- a/ext/polars/src/expr/mod.rs
+++ b/ext/polars/src/expr/mod.rs
@@ -5,6 +5,7 @@ mod datetime;
 mod general;
 mod list;
 mod meta;
+mod name;
 mod rolling;
 mod string;
 mod r#struct;
diff --git a/ext/polars/src/expr/name.rs b/ext/polars/src/expr/name.rs
new file mode 100644
index 0000000000..37f6e44637
--- /dev/null
+++ b/ext/polars/src/expr/name.rs
@@ -0,0 +1,44 @@
+use magnus::{block::Proc, value::Opaque, Ruby};
+use polars::prelude::*;
+
+use crate::RbExpr;
+
+impl RbExpr {
+    pub fn name_keep(&self) -> Self {
+        self.inner.clone().name().keep().into()
+    }
+
+    pub fn name_map(&self, lambda: Proc) -> Self {
+        let lambda = Opaque::from(lambda);
+        self.inner
+            .clone()
+            .name()
+            .map(move |name| {
+                let lambda = Ruby::get().unwrap().get_inner(lambda);
+                let out = lambda.call::<_, String>((name,));
+                match out {
+                    Ok(out) => Ok(out),
+                    Err(e) => Err(PolarsError::ComputeError(
+                        format!("Ruby function in 'name.map' produced an error: {}.", e).into(),
+                    )),
+                }
+            })
+            .into()
+    }
+
+    pub fn name_prefix(&self, prefix: String) -> Self {
+        self.inner.clone().name().prefix(&prefix).into()
+    }
+
+    pub fn name_suffix(&self, suffix: String) -> Self {
+        self.inner.clone().name().suffix(&suffix).into()
+    }
+
+    pub fn name_to_lowercase(&self) -> Self {
+        self.inner.clone().name().to_lowercase().into()
+    }
+
+    pub fn name_to_uppercase(&self) -> Self {
+        self.inner.clone().name().to_uppercase().into()
+    }
+}
diff --git a/ext/polars/src/expr/string.rs b/ext/polars/src/expr/string.rs
index 0865b563ac..0e9570f9cf 100644
--- a/ext/polars/src/expr/string.rs
+++ b/ext/polars/src/expr/string.rs
@@ -63,36 +63,48 @@ impl RbExpr {
         self.inner.clone().str().to_time(options).into()
     }
 
-    pub fn str_strip_chars(&self, matches: Option<String>) -> Self {
-        self.inner.clone().str().strip_chars(matches).into()
+    pub fn str_strip_chars(&self, matches: &Self) -> Self {
+        self.inner
+            .clone()
+            .str()
+            .strip_chars(matches.inner.clone())
+            .into()
     }
 
-    pub fn str_strip_chars_start(&self, matches: Option<String>) -> Self {
-        self.inner.clone().str().strip_chars_start(matches).into()
+    pub fn str_strip_chars_start(&self, matches: &Self) -> Self {
+        self.inner
+            .clone()
+            .str()
+            .strip_chars_start(matches.inner.clone())
+            .into()
     }
 
-    pub fn str_strip_chars_end(&self, matches: Option<String>) -> Self {
-        self.inner.clone().str().strip_chars_end(matches).into()
+    pub fn str_strip_chars_end(&self, matches: &Self) -> Self {
+        self.inner
+            .clone()
+            .str()
+            .strip_chars_end(matches.inner.clone())
+            .into()
     }
 
-    pub fn str_strip_prefix(&self, prefix: String) -> Self {
-        self.inner.clone().str().strip_prefix(prefix).into()
+    pub fn str_strip_prefix(&self, prefix: &Self) -> Self {
+        self.inner
+            .clone()
+            .str()
+            .strip_prefix(prefix.inner.clone())
+            .into()
     }
 
-    pub fn str_strip_suffix(&self, suffix: String) -> Self {
-        self.inner.clone().str().strip_suffix(suffix).into()
+    pub fn str_strip_suffix(&self, suffix: &Self) -> Self {
+        self.inner
+            .clone()
+            .str()
+            .strip_suffix(suffix.inner.clone())
+            .into()
     }
 
     pub fn str_slice(&self, start: i64, length: Option<u64>) -> Self {
-        let function = move |s: Series| {
-            let ca = s.utf8()?;
-            Ok(Some(ca.str_slice(start, length)?.into_series()))
-        };
-        self.clone()
-            .inner
-            .map(function, GetOutput::from_type(DataType::Utf8))
-            .with_fmt("str.slice")
-            .into()
+        self.inner.clone().str().slice(start, length).into()
     }
 
     pub fn str_explode(&self) -> Self {
@@ -107,28 +119,12 @@ impl RbExpr {
         self.inner.clone().str().to_lowercase().into()
     }
 
-    pub fn str_lengths(&self) -> Self {
-        let function = |s: Series| {
-            let ca = s.utf8()?;
-            Ok(Some(ca.str_lengths().into_series()))
-        };
-        self.clone()
-            .inner
-            .map(function, GetOutput::from_type(DataType::UInt32))
-            .with_fmt("str.lengths")
-            .into()
+    pub fn str_len_bytes(&self) -> Self {
+        self.inner.clone().str().len_bytes().into()
     }
 
-    pub fn str_n_chars(&self) -> Self {
-        let function = |s: Series| {
-            let ca = s.utf8()?;
-            Ok(Some(ca.str_n_chars().into_series()))
-        };
-        self.clone()
-            .inner
-            .map(function, GetOutput::from_type(DataType::UInt32))
-            .with_fmt("str.n_chars")
-            .into()
+    pub fn str_len_chars(&self) -> Self {
+        self.inner.clone().str().len_chars().into()
     }
 
     pub fn str_replace_n(&self, pat: &RbExpr, val: &RbExpr, literal: bool, n: i64) -> Self {
@@ -147,16 +143,16 @@ impl RbExpr {
             .into()
     }
 
-    pub fn str_zfill(&self, alignment: usize) -> Self {
-        self.clone().inner.str().zfill(alignment).into()
+    pub fn str_pad_start(&self, length: usize, fillchar: char) -> Self {
+        self.clone().inner.str().pad_start(length, fillchar).into()
     }
 
-    pub fn str_ljust(&self, width: usize, fillchar: char) -> Self {
-        self.clone().inner.str().ljust(width, fillchar).into()
+    pub fn str_pad_end(&self, length: usize, fillchar: char) -> Self {
+        self.clone().inner.str().pad_end(length, fillchar).into()
     }
 
-    pub fn str_rjust(&self, width: usize, fillchar: char) -> Self {
-        self.clone().inner.str().rjust(width, fillchar).into()
+    pub fn str_zfill(&self, alignment: usize) -> Self {
+        self.clone().inner.str().zfill(alignment).into()
     }
 
     pub fn str_contains(&self, pat: &RbExpr, literal: Option<bool>, strict: bool) -> Self {
@@ -319,19 +315,23 @@ impl RbExpr {
             .into()
     }
 
-    pub fn str_split_exact(&self, by: String, n: usize) -> Self {
-        self.inner.clone().str().split_exact(&by, n).into()
+    pub fn str_split_exact(&self, by: &Self, n: usize) -> Self {
+        self.inner
+            .clone()
+            .str()
+            .split_exact(by.inner.clone(), n)
+            .into()
     }
 
-    pub fn str_split_exact_inclusive(&self, by: String, n: usize) -> Self {
+    pub fn str_split_exact_inclusive(&self, by: &Self, n: usize) -> Self {
         self.inner
             .clone()
             .str()
-            .split_exact_inclusive(&by, n)
+            .split_exact_inclusive(by.inner.clone(), n)
             .into()
     }
 
-    pub fn str_splitn(&self, by: String, n: usize) -> Self {
-        self.inner.clone().str().splitn(&by, n).into()
+    pub fn str_splitn(&self, by: &Self, n: usize) -> Self {
+        self.inner.clone().str().splitn(by.inner.clone(), n).into()
     }
 }
diff --git a/ext/polars/src/functions/eager.rs b/ext/polars/src/functions/eager.rs
index b5a9edd75b..69ab2c19e7 100644
--- a/ext/polars/src/functions/eager.rs
+++ b/ext/polars/src/functions/eager.rs
@@ -50,20 +50,20 @@ pub fn concat_series(seq: RArray) -> RbResult<RbSeries> {
     Ok(s.into())
 }
 
-pub fn diag_concat_df(seq: RArray) -> RbResult<RbDataFrame> {
+pub fn concat_df_diagonal(seq: RArray) -> RbResult<RbDataFrame> {
     let mut dfs = Vec::new();
     for item in seq.each() {
         dfs.push(get_df(item?)?);
     }
-    let df = functions::diag_concat_df(&dfs).map_err(RbPolarsErr::from)?;
+    let df = functions::concat_df_diagonal(&dfs).map_err(RbPolarsErr::from)?;
     Ok(df.into())
 }
 
-pub fn hor_concat_df(seq: RArray) -> RbResult<RbDataFrame> {
+pub fn concat_df_horizontal(seq: RArray) -> RbResult<RbDataFrame> {
     let mut dfs = Vec::new();
     for item in seq.each() {
         dfs.push(get_df(item?)?);
     }
-    let df = functions::hor_concat_df(&dfs).map_err(RbPolarsErr::from)?;
+    let df = functions::concat_df_horizontal(&dfs).map_err(RbPolarsErr::from)?;
     Ok(df.into())
 }
diff --git a/ext/polars/src/functions/io.rs b/ext/polars/src/functions/io.rs
index e76b565865..33b77cc040 100644
--- a/ext/polars/src/functions/io.rs
+++ b/ext/polars/src/functions/io.rs
@@ -8,7 +8,7 @@ use crate::{RbPolarsErr, RbResult};
 pub fn read_ipc_schema(rb_f: Value) -> RbResult<RHash> {
     use polars_core::export::arrow::io::ipc::read::read_file_metadata;
     let mut r = get_file_like(rb_f, false)?;
-    let metadata = read_file_metadata(&mut r).map_err(RbPolarsErr::arrow)?;
+    let metadata = read_file_metadata(&mut r).map_err(RbPolarsErr::from)?;
 
     let dict = RHash::new();
     for field in metadata.schema.fields {
@@ -22,8 +22,8 @@ pub fn read_parquet_schema(rb_f: Value) -> RbResult<RHash> {
     use polars_core::export::arrow::io::parquet::read::{infer_schema, read_metadata};
 
     let mut r = get_file_like(rb_f, false)?;
-    let metadata = read_metadata(&mut r).map_err(RbPolarsErr::arrow)?;
-    let arrow_schema = infer_schema(&metadata).map_err(RbPolarsErr::arrow)?;
+    let metadata = read_metadata(&mut r).map_err(RbPolarsErr::from)?;
+    let arrow_schema = infer_schema(&metadata).map_err(RbPolarsErr::from)?;
 
     let dict = RHash::new();
     for field in arrow_schema.fields {
diff --git a/ext/polars/src/functions/lazy.rs b/ext/polars/src/functions/lazy.rs
index 98e5083f4a..ac326f4ff2 100644
--- a/ext/polars/src/functions/lazy.rs
+++ b/ext/polars/src/functions/lazy.rs
@@ -28,7 +28,7 @@ pub fn arg_where(condition: &RbExpr) -> RbExpr {
 
 pub fn as_struct(exprs: RArray) -> RbResult<RbExpr> {
     let exprs = rb_exprs_to_exprs(exprs)?;
-    Ok(dsl::as_struct(&exprs).into())
+    Ok(dsl::as_struct(exprs).into())
 }
 
 pub fn coalesce(exprs: RArray) -> RbResult<RbExpr> {
@@ -83,7 +83,12 @@ pub fn concat_lf(
     Ok(lf.into())
 }
 
-pub fn diag_concat_lf(lfs: RArray, rechunk: bool, parallel: bool) -> RbResult<RbLazyFrame> {
+pub fn concat_lf_diagonal(
+    lfs: RArray,
+    rechunk: bool,
+    parallel: bool,
+    to_supertypes: bool,
+) -> RbResult<RbLazyFrame> {
     let iter = lfs.each();
 
     let lfs = iter
@@ -93,40 +98,50 @@ pub fn diag_concat_lf(lfs: RArray, rechunk: bool, parallel: bool) -> RbResult<Rb
         })
         .collect::<RbResult<Vec<_>>>()?;
 
-    let lf = dsl::functions::diag_concat_lf(lfs, rechunk, parallel).map_err(RbPolarsErr::from)?;
+    let lf = dsl::functions::concat_lf_diagonal(
+        lfs,
+        UnionArgs {
+            rechunk,
+            parallel,
+            to_supertypes,
+        },
+    )
+    .map_err(RbPolarsErr::from)?;
     Ok(lf.into())
 }
 
 #[allow(clippy::too_many_arguments)]
 pub fn duration(
+    weeks: Option<&RbExpr>,
     days: Option<&RbExpr>,
+    hours: Option<&RbExpr>,
+    minutes: Option<&RbExpr>,
     seconds: Option<&RbExpr>,
-    nanoseconds: Option<&RbExpr>,
-    microseconds: Option<&RbExpr>,
     milliseconds: Option<&RbExpr>,
-    minutes: Option<&RbExpr>,
-    hours: Option<&RbExpr>,
-    weeks: Option<&RbExpr>,
+    microseconds: Option<&RbExpr>,
+    nanoseconds: Option<&RbExpr>,
+    time_unit: Wrap<TimeUnit>,
 ) -> RbExpr {
     set_unwrapped_or_0!(
+        weeks,
         days,
+        hours,
+        minutes,
         seconds,
-        nanoseconds,
-        microseconds,
         milliseconds,
-        minutes,
-        hours,
-        weeks,
+        microseconds,
+        nanoseconds,
     );
     let args = DurationArgs {
+        weeks,
         days,
+        hours,
+        minutes,
         seconds,
-        nanoseconds,
-        microseconds,
         milliseconds,
-        minutes,
-        hours,
-        weeks,
+        microseconds,
+        nanoseconds,
+        time_unit: time_unit.0,
     };
     dsl::duration(args).into()
 }
diff --git a/ext/polars/src/functions/meta.rs b/ext/polars/src/functions/meta.rs
index 8a7835ab4b..650ecb2b30 100644
--- a/ext/polars/src/functions/meta.rs
+++ b/ext/polars/src/functions/meta.rs
@@ -15,14 +15,6 @@ pub fn threadpool_size() -> usize {
     POOL.current_num_threads()
 }
 
-pub fn enable_string_cache(toggle: bool) {
-    polars_core::enable_string_cache(toggle)
-}
-
-pub fn using_string_cache() -> bool {
-    polars_core::using_string_cache()
-}
-
 pub fn set_float_fmt(fmt: String) -> RbResult<()> {
     let fmt = match fmt.as_str() {
         "full" => FloatFmt::Full,
diff --git a/ext/polars/src/functions/mod.rs b/ext/polars/src/functions/mod.rs
index e9648cb4f5..b9470f8a65 100644
--- a/ext/polars/src/functions/mod.rs
+++ b/ext/polars/src/functions/mod.rs
@@ -6,4 +6,5 @@ pub mod meta;
 pub mod misc;
 pub mod random;
 pub mod range;
+pub mod string_cache;
 pub mod whenthen;
diff --git a/ext/polars/src/functions/string_cache.rs b/ext/polars/src/functions/string_cache.rs
new file mode 100644
index 0000000000..b0b04373dc
--- /dev/null
+++ b/ext/polars/src/functions/string_cache.rs
@@ -0,0 +1,11 @@
+pub fn enable_string_cache() {
+    polars_core::enable_string_cache()
+}
+
+pub fn disable_string_cache() {
+    polars_core::disable_string_cache()
+}
+
+pub fn using_string_cache() -> bool {
+    polars_core::using_string_cache()
+}
diff --git a/ext/polars/src/lazyframe.rs b/ext/polars/src/lazyframe.rs
index 345ccda1b2..30ff47c42c 100644
--- a/ext/polars/src/lazyframe.rs
+++ b/ext/polars/src/lazyframe.rs
@@ -79,7 +79,7 @@ impl RbLazyFrame {
         // start arguments
         // this pattern is needed for more than 16
         let path = String::try_convert(arguments[0])?;
-        let sep = String::try_convert(arguments[1])?;
+        let separator = String::try_convert(arguments[1])?;
         let has_header = bool::try_convert(arguments[2])?;
         let ignore_errors = bool::try_convert(arguments[3])?;
         let skip_rows = usize::try_convert(arguments[4])?;
@@ -103,7 +103,7 @@ impl RbLazyFrame {
         let null_values = null_values.map(|w| w.0);
         let comment_char = comment_char.map(|s| s.as_bytes()[0]);
         let quote_char = quote_char.map(|s| s.as_bytes()[0]);
-        let delimiter = sep.as_bytes()[0];
+        let separator = separator.as_bytes()[0];
         let eol_char = eol_char.as_bytes()[0];
 
         let row_count = row_count.map(|(name, offset)| RowCount { name, offset });
@@ -116,7 +116,7 @@ impl RbLazyFrame {
         });
         let r = LazyCsvReader::new(path)
             .with_infer_schema_length(infer_schema_length)
-            .with_delimiter(delimiter)
+            .with_separator(separator)
             .has_header(has_header)
             .with_ignore_errors(ignore_errors)
             .with_skip_rows(skip_rows)
@@ -151,6 +151,7 @@ impl RbLazyFrame {
         row_count: Option<(String, IdxSize)>,
         low_memory: bool,
         use_statistics: bool,
+        hive_partitioning: bool,
     ) -> RbResult<Self> {
         let row_count = row_count.map(|(name, offset)| RowCount { name, offset });
         let args = ScanArgsParquet {
@@ -163,6 +164,7 @@ impl RbLazyFrame {
             // TODO support cloud options
             cloud_options: None,
             use_statistics,
+            hive_partitioning,
         };
         let lf = LazyFrame::scan_parquet(path, args).map_err(RbPolarsErr::from)?;
         Ok(lf.into())
@@ -367,11 +369,12 @@ impl RbLazyFrame {
         every: String,
         period: String,
         offset: String,
-        truncate: bool,
+        label: Wrap<Label>,
         include_boundaries: bool,
         closed: Wrap<ClosedWindow>,
         by: RArray,
         start_by: Wrap<StartBy>,
+        check_sorted: bool,
     ) -> RbResult<RbLazyGroupBy> {
         let closed_window = closed.0;
         let by = rb_exprs_to_exprs(by)?;
@@ -383,10 +386,11 @@ impl RbLazyFrame {
                 every: Duration::parse(&every),
                 period: Duration::parse(&period),
                 offset: Duration::parse(&offset),
-                truncate,
+                label: label.0,
                 include_boundaries,
                 closed_window,
                 start_by: start_by.0,
+                check_sorted,
                 ..Default::default()
             },
         );
diff --git a/ext/polars/src/lib.rs b/ext/polars/src/lib.rs
index 0a4d989226..6093d4f899 100644
--- a/ext/polars/src/lib.rs
+++ b/ext/polars/src/lib.rs
@@ -50,12 +50,12 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         function!(crate::functions::lazy::dtype_cols2, 1),
     )?;
     module.define_singleton_method(
-        "_diag_concat_lf",
-        function!(crate::functions::lazy::diag_concat_lf, 3),
+        "_concat_lf_diagonal",
+        function!(crate::functions::lazy::concat_lf_diagonal, 4),
     )?;
     module.define_singleton_method(
         "_rb_duration",
-        function!(crate::functions::lazy::duration, 8),
+        function!(crate::functions::lazy::duration, 9),
     )?;
     module.define_singleton_method(
         "_concat_df",
@@ -66,12 +66,12 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         function!(crate::functions::lazy::concat_lf, 4),
     )?;
     module.define_singleton_method(
-        "_diag_concat_df",
-        function!(crate::functions::eager::diag_concat_df, 1),
+        "_concat_df_diagonal",
+        function!(crate::functions::eager::concat_df_diagonal, 1),
     )?;
     module.define_singleton_method(
-        "_hor_concat_df",
-        function!(crate::functions::eager::hor_concat_df, 1),
+        "_concat_df_horizontal",
+        function!(crate::functions::eager::concat_df_horizontal, 1),
     )?;
     module.define_singleton_method(
         "_concat_series",
@@ -139,11 +139,15 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     module.define_singleton_method(
         "_enable_string_cache",
-        function!(crate::functions::meta::enable_string_cache, 1),
+        function!(crate::functions::string_cache::enable_string_cache, 0),
+    )?;
+    module.define_singleton_method(
+        "_disable_string_cache",
+        function!(crate::functions::string_cache::disable_string_cache, 0),
     )?;
     module.define_singleton_method(
         "_using_string_cache",
-        function!(crate::functions::meta::using_string_cache, 0),
+        function!(crate::functions::string_cache::using_string_cache, 0),
     )?;
     module.define_singleton_method(
         "_set_float_fmt",
@@ -312,6 +316,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("arg_sort", method!(RbExpr::arg_sort, 2))?;
     class.define_method("top_k", method!(RbExpr::top_k, 1))?;
     class.define_method("bottom_k", method!(RbExpr::bottom_k, 1))?;
+    class.define_method("peak_min", method!(RbExpr::peak_min, 0))?;
+    class.define_method("peak_max", method!(RbExpr::peak_max, 0))?;
     class.define_method("arg_max", method!(RbExpr::arg_max, 0))?;
     class.define_method("arg_min", method!(RbExpr::arg_min, 0))?;
     class.define_method("search_sorted", method!(RbExpr::search_sorted, 2))?;
@@ -348,8 +354,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("floor", method!(RbExpr::floor, 0))?;
     class.define_method("ceil", method!(RbExpr::ceil, 0))?;
     class.define_method("clip", method!(RbExpr::clip, 2))?;
-    class.define_method("clip_min", method!(RbExpr::clip_min, 1))?;
-    class.define_method("clip_max", method!(RbExpr::clip_max, 1))?;
     class.define_method("abs", method!(RbExpr::abs, 0))?;
     class.define_method("sin", method!(RbExpr::sin, 0))?;
     class.define_method("cos", method!(RbExpr::cos, 0))?;
@@ -396,13 +400,13 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_explode", method!(RbExpr::str_explode, 0))?;
     class.define_method("str_to_uppercase", method!(RbExpr::str_to_uppercase, 0))?;
     class.define_method("str_to_lowercase", method!(RbExpr::str_to_lowercase, 0))?;
-    class.define_method("str_lengths", method!(RbExpr::str_lengths, 0))?;
-    class.define_method("str_n_chars", method!(RbExpr::str_n_chars, 0))?;
+    class.define_method("str_len_bytes", method!(RbExpr::str_len_bytes, 0))?;
+    class.define_method("str_len_chars", method!(RbExpr::str_len_chars, 0))?;
     class.define_method("str_replace_n", method!(RbExpr::str_replace_n, 4))?;
     class.define_method("str_replace_all", method!(RbExpr::str_replace_all, 3))?;
     class.define_method("str_zfill", method!(RbExpr::str_zfill, 1))?;
-    class.define_method("str_ljust", method!(RbExpr::str_ljust, 2))?;
-    class.define_method("str_rjust", method!(RbExpr::str_rjust, 2))?;
+    class.define_method("str_pad_start", method!(RbExpr::str_pad_start, 2))?;
+    class.define_method("str_pad_end", method!(RbExpr::str_pad_end, 2))?;
     class.define_method("str_contains", method!(RbExpr::str_contains, 3))?;
     class.define_method("str_ends_with", method!(RbExpr::str_ends_with, 1))?;
     class.define_method("str_starts_with", method!(RbExpr::str_starts_with, 1))?;
@@ -447,7 +451,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbExpr::str_split_exact_inclusive, 2),
     )?;
     class.define_method("str_splitn", method!(RbExpr::str_splitn, 2))?;
-    class.define_method("list_lengths", method!(RbExpr::list_lengths, 0))?;
+    class.define_method("list_len", method!(RbExpr::list_len, 0))?;
     class.define_method("list_contains", method!(RbExpr::list_contains, 1))?;
     class.define_method("list_count_matches", method!(RbExpr::list_count_matches, 1))?;
     class.define_method("year", method!(RbExpr::dt_year, 0))?;
@@ -500,16 +504,12 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dt_truncate", method!(RbExpr::dt_truncate, 3))?;
     class.define_method("dt_month_start", method!(RbExpr::dt_month_start, 0))?;
     class.define_method("dt_month_end", method!(RbExpr::dt_month_end, 0))?;
-    class.define_method("dt_round", method!(RbExpr::dt_round, 2))?;
+    class.define_method("dt_round", method!(RbExpr::dt_round, 3))?;
     class.define_method("dt_combine", method!(RbExpr::dt_combine, 2))?;
     class.define_method("map", method!(RbExpr::map, 3))?;
     class.define_method("dot", method!(RbExpr::dot, 1))?;
     class.define_method("reinterpret", method!(RbExpr::reinterpret, 1))?;
     class.define_method("mode", method!(RbExpr::mode, 0))?;
-    class.define_method("keep_name", method!(RbExpr::keep_name, 0))?;
-    class.define_method("prefix", method!(RbExpr::prefix, 1))?;
-    class.define_method("suffix", method!(RbExpr::suffix, 1))?;
-    class.define_method("map_alias", method!(RbExpr::map_alias, 1))?;
     class.define_method("exclude", method!(RbExpr::exclude, 1))?;
     class.define_method("interpolate", method!(RbExpr::interpolate, 1))?;
     class.define_method("rolling_sum", method!(RbExpr::rolling_sum, 6))?;
@@ -593,6 +593,14 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbExpr::meta_is_regex_projection, 0),
     )?;
 
+    // name
+    class.define_method("name_keep", method!(RbExpr::name_keep, 0))?;
+    class.define_method("name_map", method!(RbExpr::name_map, 1))?;
+    class.define_method("name_prefix", method!(RbExpr::name_prefix, 1))?;
+    class.define_method("name_suffix", method!(RbExpr::name_suffix, 1))?;
+    class.define_method("name_to_lowercase", method!(RbExpr::name_to_lowercase, 0))?;
+    class.define_method("name_to_uppercase", method!(RbExpr::name_to_uppercase, 0))?;
+
     // maybe add to different class
     class.define_singleton_method("col", function!(crate::functions::lazy::col, 1))?;
     class.define_singleton_method("count", function!(crate::functions::lazy::count, 0))?;
@@ -643,7 +651,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("new_from_csv", function!(RbLazyFrame::new_from_csv, -1))?;
     class.define_singleton_method(
         "new_from_parquet",
-        function!(RbLazyFrame::new_from_parquet, 8),
+        function!(RbLazyFrame::new_from_parquet, 9),
     )?;
     class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 6))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
@@ -671,7 +679,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_method(
         "group_by_dynamic",
-        method!(RbLazyFrame::group_by_dynamic, 9),
+        method!(RbLazyFrame::group_by_dynamic, 10),
     )?;
     class.define_method("with_context", method!(RbLazyFrame::with_context, 1))?;
     class.define_method("join_asof", method!(RbLazyFrame::join_asof, 11))?;
@@ -800,8 +808,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("apply_lambda", method!(RbSeries::apply_lambda, 3))?;
     class.define_method("zip_with", method!(RbSeries::zip_with, 2))?;
     class.define_method("to_dummies", method!(RbSeries::to_dummies, 2))?;
-    class.define_method("peak_max", method!(RbSeries::peak_max, 0))?;
-    class.define_method("peak_min", method!(RbSeries::peak_min, 0))?;
     class.define_method("n_unique", method!(RbSeries::n_unique, 0))?;
     class.define_method("floor", method!(RbSeries::floor, 0))?;
     class.define_method("shrink_to_fit", method!(RbSeries::shrink_to_fit, 0))?;
diff --git a/ext/polars/src/series.rs b/ext/polars/src/series.rs
index 308a0f152a..b338e9c3e4 100644
--- a/ext/polars/src/series.rs
+++ b/ext/polars/src/series.rs
@@ -643,14 +643,6 @@ impl RbSeries {
         Ok(df.into())
     }
 
-    pub fn peak_max(&self) -> Self {
-        self.series.borrow().peak_max().into_series().into()
-    }
-
-    pub fn peak_min(&self) -> Self {
-        self.series.borrow().peak_min().into_series().into()
-    }
-
     pub fn n_unique(&self) -> RbResult<usize> {
         let n = self.series.borrow().n_unique().map_err(RbPolarsErr::from)?;
         Ok(n)
diff --git a/lib/polars.rb b/lib/polars.rb
index cedd377650..7a0e961355 100644
--- a/lib/polars.rb
+++ b/lib/polars.rb
@@ -38,6 +38,7 @@
 require_relative "polars/list_expr"
 require_relative "polars/list_name_space"
 require_relative "polars/meta_expr"
+require_relative "polars/name_expr"
 require_relative "polars/rolling_group_by"
 require_relative "polars/series"
 require_relative "polars/slice"
diff --git a/lib/polars/data_frame.rb b/lib/polars/data_frame.rb
index b4e3951acd..251142c5be 100644
--- a/lib/polars/data_frame.rb
+++ b/lib/polars/data_frame.rb
@@ -4282,15 +4282,20 @@ def sample(
       end
 
       if n.nil? && !frac.nil?
+        frac = Series.new("frac", [frac]) unless frac.is_a?(Series)
+
         _from_rbdf(
-          _df.sample_frac(frac, with_replacement, shuffle, seed)
+          _df.sample_frac(frac._s, with_replacement, shuffle, seed)
         )
       end
 
       if n.nil?
         n = 1
       end
-      _from_rbdf(_df.sample_n(n, with_replacement, shuffle, seed))
+
+      n = Series.new("", [n]) unless n.is_a?(Series)
+
+      _from_rbdf(_df.sample_n(n._s, with_replacement, shuffle, seed))
     end
 
     # Apply a horizontal reduction on a DataFrame.
@@ -4659,16 +4664,16 @@ def hash_rows(seed: 0, seed_1: nil, seed_2: nil, seed_3: nil)
     #   df.interpolate
     #   # =>
     #   # shape: (4, 3)
-    #   # ┌─────┬──────┬─────┐
-    #   # │ foo ┆ bar  ┆ baz │
-    #   # │ --- ┆ ---  ┆ --- │
-    #   # │ i64 ┆ i64  ┆ i64 │
-    #   # ╞═════╪══════╪═════╡
-    #   # │ 1   ┆ 6    ┆ 1   │
-    #   # │ 5   ┆ 7    ┆ 3   │
-    #   # │ 9   ┆ 9    ┆ 6   │
-    #   # │ 10  ┆ null ┆ 9   │
-    #   # └─────┴──────┴─────┘
+    #   # ┌──────┬──────┬──────────┐
+    #   # │ foo  ┆ bar  ┆ baz      │
+    #   # │ ---  ┆ ---  ┆ ---      │
+    #   # │ f64  ┆ f64  ┆ f64      │
+    #   # ╞══════╪══════╪══════════╡
+    #   # │ 1.0  ┆ 6.0  ┆ 1.0      │
+    #   # │ 5.0  ┆ 7.0  ┆ 3.666667 │
+    #   # │ 9.0  ┆ 9.0  ┆ 6.333333 │
+    #   # │ 10.0 ┆ null ┆ 9.0      │
+    #   # └──────┴──────┴──────────┘
     def interpolate
       select(Utils.col("*").interpolate)
     end
diff --git a/lib/polars/date_time_expr.rb b/lib/polars/date_time_expr.rb
index 1a7aac00a0..a94311c2ec 100644
--- a/lib/polars/date_time_expr.rb
+++ b/lib/polars/date_time_expr.rb
@@ -104,9 +104,14 @@ def truncate(every, offset: nil, use_earliest: nil, ambiguous: "raise")
         offset = "0ns"
       end
 
+      if !every.is_a?(Expr)
+        every = Utils._timedelta_to_pl_duration(every)
+      end
+      every = Utils.parse_as_expression(every, str_as_lit: true)
+
       Utils.wrap_expr(
         _rbexpr.dt_truncate(
-          Utils._timedelta_to_pl_duration(every),
+          every,
           Utils._timedelta_to_pl_duration(offset),
           ambiguous._rbexpr
         )
@@ -208,15 +213,18 @@ def truncate(every, offset: nil, use_earliest: nil, ambiguous: "raise")
     #   # │ 2001-01-01 00:50:00 ┆ 2001-01-01 01:00:00 │
     #   # │ 2001-01-01 01:00:00 ┆ 2001-01-01 01:00:00 │
     #   # └─────────────────────┴─────────────────────┘
-    def round(every, offset: nil)
+    def round(every, offset: nil, ambiguous: "raise")
       if offset.nil?
         offset = "0ns"
       end
 
+      ambiguous = Polars.lit(ambiguous) unless ambiguous.is_a?(Expr)
+
       Utils.wrap_expr(
         _rbexpr.dt_round(
           Utils._timedelta_to_pl_duration(every),
-          Utils._timedelta_to_pl_duration(offset)
+          Utils._timedelta_to_pl_duration(offset),
+          ambiguous._rbexpr
         )
       )
     end
diff --git a/lib/polars/expr.rb b/lib/polars/expr.rb
index a65a6c642a..0622bc18ba 100644
--- a/lib/polars/expr.rb
+++ b/lib/polars/expr.rb
@@ -408,21 +408,21 @@ def exclude(columns)
     #   # │ 18  ┆ 4   │
     #   # └─────┴─────┘
     def keep_name
-      wrap_expr(_rbexpr.keep_name)
+      name.keep
     end
 
     # Add a prefix to the root column name of the expression.
     #
     # @return [Expr]
     def prefix(prefix)
-      wrap_expr(_rbexpr.prefix(prefix))
+      name.prefix(prefix)
     end
 
     # Add a suffix to the root column name of the expression.
     #
     # @return [Expr]
     def suffix(suffix)
-      wrap_expr(_rbexpr.suffix(suffix))
+      name.suffix(suffix)
     end
 
     # Rename the output of an expression by mapping a function over the root name.
@@ -450,7 +450,7 @@ def suffix(suffix)
     #   # │ 1         ┆ 3         │
     #   # └───────────┴───────────┘
     def map_alias(&f)
-      Utils.wrap_expr(_rbexpr.map_alias(f))
+      name.map(&f)
     end
 
     # Negate a boolean expression.
@@ -1344,6 +1344,7 @@ def sort(reverse: false, nulls_last: false)
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
     def top_k(k: 5)
+      k = Utils.parse_as_expression(k)
       wrap_expr(_rbexpr.top_k(k))
     end
 
@@ -1382,6 +1383,7 @@ def top_k(k: 5)
     #   # │ 2     ┆ 98       │
     #   # └───────┴──────────┘
     def bottom_k(k: 5)
+      k = Utils.parse_as_expression(k)
       wrap_expr(_rbexpr.bottom_k(k))
     end
 
@@ -1573,17 +1575,17 @@ def sort_by(by, reverse: false)
     #       "value" => [1, 98, 2, 3, 99, 4]
     #     }
     #   )
-    #   df.groupby("group", maintain_order: true).agg(Polars.col("value").take(1))
+    #   df.group_by("group", maintain_order: true).agg(Polars.col("value").take([2, 1]))
     #   # =>
     #   # shape: (2, 2)
-    #   # ┌───────┬───────┐
-    #   # │ group ┆ value │
-    #   # │ ---   ┆ ---   │
-    #   # │ str   ┆ i64   │
-    #   # ╞═══════╪═══════╡
-    #   # │ one   ┆ 98    │
-    #   # │ two   ┆ 99    │
-    #   # └───────┴───────┘
+    #   # ┌───────┬───────────┐
+    #   # │ group ┆ value     │
+    #   # │ ---   ┆ ---       │
+    #   # │ str   ┆ list[i64] │
+    #   # ╞═══════╪═══════════╡
+    #   # │ one   ┆ [2, 98]   │
+    #   # │ two   ┆ [4, 99]   │
+    #   # └───────┴───────────┘
     def take(indices)
       if indices.is_a?(::Array)
         indices_lit = Polars.lit(Series.new("", indices, dtype: :u32))
@@ -2343,6 +2345,54 @@ def is_duplicated
       wrap_expr(_rbexpr.is_duplicated)
     end
 
+    # Get a boolean mask of the local maximum peaks.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [1, 2, 3, 4, 5]})
+    #   df.select(Polars.col("a").peak_max)
+    #   # =>
+    #   # shape: (5, 1)
+    #   # ┌───────┐
+    #   # │ a     │
+    #   # │ ---   │
+    #   # │ bool  │
+    #   # ╞═══════╡
+    #   # │ false │
+    #   # │ false │
+    #   # │ false │
+    #   # │ false │
+    #   # │ true  │
+    #   # └───────┘
+    def peak_max
+      wrap_expr(_rbexpr.peak_max)
+    end
+
+    # Get a boolean mask of the local minimum peaks.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a" => [4, 1, 3, 2, 5]})
+    #   df.select(Polars.col("a").peak_min)
+    #   # =>
+    #   # shape: (5, 1)
+    #   # ┌───────┐
+    #   # │ a     │
+    #   # │ ---   │
+    #   # │ bool  │
+    #   # ╞═══════╡
+    #   # │ false │
+    #   # │ true  │
+    #   # │ false │
+    #   # │ true  │
+    #   # │ false │
+    #   # └───────┘
+    def peak_min
+      wrap_expr(_rbexpr.peak_min)
+    end
+
     # Get quantile value.
     #
     # @param quantile [Float]
@@ -3065,11 +3115,11 @@ def reinterpret(signed: false)
     #   # ┌─────┬─────┐
     #   # │ a   ┆ b   │
     #   # │ --- ┆ --- │
-    #   # │ i64 ┆ f64 │
+    #   # │ f64 ┆ f64 │
     #   # ╞═════╪═════╡
-    #   # │ 1   ┆ 1.0 │
-    #   # │ 2   ┆ NaN │
-    #   # │ 3   ┆ 3.0 │
+    #   # │ 1.0 ┆ 1.0 │
+    #   # │ 2.0 ┆ NaN │
+    #   # │ 3.0 ┆ 3.0 │
     #   # └─────┴─────┘
     def interpolate(method: "linear")
       wrap_expr(_rbexpr.interpolate(method))
@@ -4049,6 +4099,7 @@ def diff(n: 1, null_behavior: "ignore")
     #   # │ 12   ┆ 0.0        │
     #   # └──────┴────────────┘
     def pct_change(n: 1)
+      n = Utils.parse_as_expression(n)
       wrap_expr(_rbexpr.pct_change(n))
     end
 
@@ -4113,16 +4164,14 @@ def kurtosis(fisher: true, bias: true)
       wrap_expr(_rbexpr.kurtosis(fisher, bias))
     end
 
-    # Clip (limit) the values in an array to a `min` and `max` boundary.
-    #
-    # Only works for numerical types.
+    # Set values outside the given boundaries to the boundary value.
     #
-    # If you want to clip other dtypes, consider writing a "when, then, otherwise"
-    # expression. See `when` for more information.
+    # Only works for numeric and temporal columns. If you want to clip other data
+    # types, consider writing a `when-then-otherwise` expression.
     #
-    # @param min_val [Numeric]
+    # @param lower_bound [Numeric]
     #   Minimum value.
-    # @param max_val [Numeric]
+    # @param upper_bound [Numeric]
     #   Maximum value.
     #
     # @return [Expr]
@@ -4142,8 +4191,14 @@ def kurtosis(fisher: true, bias: true)
     #   # │ null ┆ null        │
     #   # │ 50   ┆ 10          │
     #   # └──────┴─────────────┘
-    def clip(min_val, max_val)
-      wrap_expr(_rbexpr.clip(min_val, max_val))
+    def clip(lower_bound, upper_bound)
+      if !lower_bound.nil?
+        lower_bound = Utils.parse_as_expression(lower_bound, str_as_lit: true)
+      end
+      if !upper_bound.nil?
+        upper_bound = Utils.parse_as_expression(upper_bound, str_as_lit: true)
+      end
+      wrap_expr(_rbexpr.clip(lower_bound, upper_bound))
     end
 
     # Clip (limit) the values in an array to a `min` boundary.
@@ -4153,7 +4208,7 @@ def clip(min_val, max_val)
     # If you want to clip other dtypes, consider writing a "when, then, otherwise"
     # expression. See `when` for more information.
     #
-    # @param min_val [Numeric]
+    # @param lower_bound [Numeric]
     #   Minimum value.
     #
     # @return [Expr]
@@ -4173,8 +4228,8 @@ def clip(min_val, max_val)
     #   # │ null ┆ null        │
     #   # │ 50   ┆ 50          │
     #   # └──────┴─────────────┘
-    def clip_min(min_val)
-      wrap_expr(_rbexpr.clip_min(min_val))
+    def clip_min(lower_bound)
+      clip(lower_bound, nil)
     end
 
     # Clip (limit) the values in an array to a `max` boundary.
@@ -4184,7 +4239,7 @@ def clip_min(min_val)
     # If you want to clip other dtypes, consider writing a "when, then, otherwise"
     # expression. See `when` for more information.
     #
-    # @param max_val [Numeric]
+    # @param upper_bound [Numeric]
     #   Maximum value.
     #
     # @return [Expr]
@@ -4204,8 +4259,8 @@ def clip_min(min_val)
     #   # │ null ┆ null        │
     #   # │ 50   ┆ 0           │
     #   # └──────┴─────────────┘
-    def clip_max(max_val)
-      wrap_expr(_rbexpr.clip_max(max_val))
+    def clip_max(upper_bound)
+      clip(nil, upper_bound)
     end
 
     # Calculate the lower bound.
@@ -4615,12 +4670,14 @@ def sample(
       end
 
       if !n.nil? && frac.nil?
+        n = Utils.parse_as_expression(n)
         return wrap_expr(_rbexpr.sample_n(n, with_replacement, shuffle, seed))
       end
 
       if frac.nil?
         frac = 1.0
       end
+      frac = Utils.parse_as_expression(frac)
       wrap_expr(
         _rbexpr.sample_frac(frac, with_replacement, shuffle, seed)
       )
@@ -5064,6 +5121,13 @@ def meta
       MetaExpr.new(self)
     end
 
+    # Create an object namespace of all expressions that modify expression names.
+    #
+    # @return [NameExpr]
+    def name
+      NameExpr.new(self)
+    end
+
     # Create an object namespace of all string related methods.
     #
     # @return [StringExpr]
diff --git a/lib/polars/functions.rb b/lib/polars/functions.rb
index 56558d561f..522256495f 100644
--- a/lib/polars/functions.rb
+++ b/lib/polars/functions.rb
@@ -55,9 +55,9 @@ def concat(items, rechunk: true, how: "vertical", parallel: true)
         if how == "vertical"
           out = Utils.wrap_df(_concat_df(items))
         elsif how == "diagonal"
-          out = Utils.wrap_df(_diag_concat_df(items))
+          out = Utils.wrap_df(_concat_df_diagonal(items))
         elsif how == "horizontal"
-          out = Utils.wrap_df(_hor_concat_df(items))
+          out = Utils.wrap_df(_concat_df_horizontal(items))
         else
           raise ArgumentError, "how must be one of {{'vertical', 'diagonal', 'horizontal'}}, got #{how}"
         end
@@ -67,7 +67,7 @@ def concat(items, rechunk: true, how: "vertical", parallel: true)
         elsif how == "vertical_relaxed"
           return Utils.wrap_ldf(_concat_lf(items, rechunk, parallel, true))
         elsif how == "diagonal"
-          return Utils.wrap_ldf(_diag_concat_lf(items, rechunk, parallel))
+          return Utils.wrap_ldf(_concat_lf_diagonal(items, rechunk, parallel, false))
         else
           raise ArgumentError, "Lazy only allows 'vertical', 'vertical_relaxed', and 'diagonal' concat strategy."
         end
diff --git a/lib/polars/lazy_frame.rb b/lib/polars/lazy_frame.rb
index 08b07eb8b5..8a6947e87f 100644
--- a/lib/polars/lazy_frame.rb
+++ b/lib/polars/lazy_frame.rb
@@ -97,7 +97,8 @@ def self._scan_parquet(
       row_count_offset: 0,
       storage_options: nil,
       low_memory: false,
-      use_statistics: true
+      use_statistics: true,
+      hive_partitioning: true
     )
       _from_rbldf(
         RbLazyFrame.new_from_parquet(
@@ -108,7 +109,8 @@ def self._scan_parquet(
           rechunk,
           Utils._prepare_row_count_args(row_count_name, row_count_offset),
           low_memory,
-          use_statistics
+          use_statistics,
+          hive_partitioning
         )
       )
     end
@@ -1040,7 +1042,7 @@ def group_by_rolling(
     # - "1i"      # length 1
     # - "10i"     # length 10
     #
-    # @param index_column
+    # @param index_column [Object]
     #   Column used to group based on the time window.
     #   Often to type Date/Datetime
     #   This column must be sorted in ascending order. If not the output will not
@@ -1049,23 +1051,29 @@ def group_by_rolling(
     #   In case of a dynamic groupby on indices, dtype needs to be one of
     #   `:i32`, `:i64`. Note that `:i32` gets temporarily cast to `:i64`, so if
     #   performance matters use an `:i64` column.
-    # @param every
+    # @param every [Object]
     #   Interval of the window.
-    # @param period
+    # @param period [Object]
     #   Length of the window, if None it is equal to 'every'.
-    # @param offset
+    # @param offset [Object]
     #   Offset of the window if None and period is None it will be equal to negative
     #   `every`.
-    # @param truncate
+    # @param truncate [Boolean]
     #   Truncate the time value to the window lower bound.
-    # @param include_boundaries
+    # @param include_boundaries [Boolean]
     #   Add the lower and upper bound of the window to the "_lower_bound" and
     #   "_upper_bound" columns. This will impact performance because it's harder to
     #   parallelize
     # @param closed ["right", "left", "both", "none"]
     #   Define whether the temporal window interval is closed or not.
-    # @param by
+    # @param by [Object]
     #   Also group by this column/these columns
+    # @param check_sorted [Boolean]
+    #   When the `by` argument is given, polars can not check sortedness
+    #   by the metadata and has to do a full scan on the index column to
+    #   verify data is sorted. This is expensive. If you are sure the
+    #   data within the by groups is sorted, you can set this to `false`.
+    #   Doing so incorrectly will lead to incorrect output.
     #
     # @return [DataFrame]
     #
@@ -1235,12 +1243,18 @@ def group_by_dynamic(
       every:,
       period: nil,
       offset: nil,
-      truncate: true,
+      truncate: nil,
       include_boundaries: false,
       closed: "left",
+      label: "left",
       by: nil,
-      start_by: "window"
+      start_by: "window",
+      check_sorted: true
     )
+      if !truncate.nil?
+        label = truncate ? "left" : "datapoint"
+      end
+
       index_column = Utils.expr_to_lit_or_expr(index_column, str_to_lit: false)
       if offset.nil?
         offset = period.nil? ? "-#{every}" : "0ns"
@@ -1260,11 +1274,12 @@ def group_by_dynamic(
         every,
         period,
         offset,
-        truncate,
+        label,
         include_boundaries,
         closed,
         rbexprs_by,
-        start_by
+        start_by,
+        check_sorted
       )
       LazyGroupBy.new(lgb)
     end
@@ -2374,16 +2389,16 @@ def melt(id_vars: nil, value_vars: nil, variable_name: nil, value_name: nil, str
     #   df.interpolate.collect
     #   # =>
     #   # shape: (4, 3)
-    #   # ┌─────┬──────┬─────┐
-    #   # │ foo ┆ bar  ┆ baz │
-    #   # │ --- ┆ ---  ┆ --- │
-    #   # │ i64 ┆ i64  ┆ i64 │
-    #   # ╞═════╪══════╪═════╡
-    #   # │ 1   ┆ 6    ┆ 1   │
-    #   # │ 5   ┆ 7    ┆ 3   │
-    #   # │ 9   ┆ 9    ┆ 6   │
-    #   # │ 10  ┆ null ┆ 9   │
-    #   # └─────┴──────┴─────┘
+    #   # ┌──────┬──────┬──────────┐
+    #   # │ foo  ┆ bar  ┆ baz      │
+    #   # │ ---  ┆ ---  ┆ ---      │
+    #   # │ f64  ┆ f64  ┆ f64      │
+    #   # ╞══════╪══════╪══════════╡
+    #   # │ 1.0  ┆ 6.0  ┆ 1.0      │
+    #   # │ 5.0  ┆ 7.0  ┆ 3.666667 │
+    #   # │ 9.0  ┆ 9.0  ┆ 6.333333 │
+    #   # │ 10.0 ┆ null ┆ 9.0      │
+    #   # └──────┴──────┴──────────┘
     def interpolate
       select(Utils.col("*").interpolate)
     end
diff --git a/lib/polars/lazy_functions.rb b/lib/polars/lazy_functions.rb
index bf15aa7976..4aa5b74e0e 100644
--- a/lib/polars/lazy_functions.rb
+++ b/lib/polars/lazy_functions.rb
@@ -720,15 +720,22 @@ def arg_sort_by(exprs, reverse: false)
     #   # │ 2022-01-16 00:00:00 ┆ 2022-01-04 00:00:00 ┆ 2022-01-02 00:00:02 ┆ 2022-01-02 00:00:00.002 ┆ 2022-01-02 02:00:00 │
     #   # └─────────────────────┴─────────────────────┴─────────────────────┴─────────────────────────┴─────────────────────┘
     def duration(
+      weeks: nil,
       days: nil,
+      hours: nil,
+      minutes: nil,
       seconds: nil,
-      nanoseconds: nil,
-      microseconds: nil,
       milliseconds: nil,
-      minutes: nil,
-      hours: nil,
-      weeks: nil
+      microseconds: nil,
+      nanoseconds: nil,
+      time_unit: "us"
     )
+      if !weeks.nil?
+        weeks = Utils.expr_to_lit_or_expr(weeks, str_to_lit: false)._rbexpr
+      end
+      if !days.nil?
+        days = Utils.expr_to_lit_or_expr(days, str_to_lit: false)._rbexpr
+      end
       if !hours.nil?
         hours = Utils.expr_to_lit_or_expr(hours, str_to_lit: false)._rbexpr
       end
@@ -747,23 +754,18 @@ def duration(
       if !nanoseconds.nil?
         nanoseconds = Utils.expr_to_lit_or_expr(nanoseconds, str_to_lit: false)._rbexpr
       end
-      if !days.nil?
-        days = Utils.expr_to_lit_or_expr(days, str_to_lit: false)._rbexpr
-      end
-      if !weeks.nil?
-        weeks = Utils.expr_to_lit_or_expr(weeks, str_to_lit: false)._rbexpr
-      end
 
       Utils.wrap_expr(
         _rb_duration(
+          weeks,
           days,
+          hours,
+          minutes,
           seconds,
-          nanoseconds,
-          microseconds,
           milliseconds,
-          minutes,
-          hours,
-          weeks
+          microseconds,
+          nanoseconds,
+          time_unit
         )
       )
     end
diff --git a/lib/polars/list_expr.rb b/lib/polars/list_expr.rb
index 9d4152fe8d..0fa8b1edb9 100644
--- a/lib/polars/list_expr.rb
+++ b/lib/polars/list_expr.rb
@@ -27,8 +27,9 @@ def initialize(expr)
     #   # │ 1   │
     #   # └─────┘
     def lengths
-      Utils.wrap_expr(_rbexpr.list_lengths)
+      Utils.wrap_expr(_rbexpr.list_len)
     end
+    alias_method :len, :lengths
 
     # Sum all the lists in the array.
     #
@@ -379,6 +380,7 @@ def contains(item)
     #   # │ x y   │
     #   # └───────┘
     def join(separator)
+      separator = Utils.parse_as_expression(separator, str_as_lit: true)
       Utils.wrap_expr(_rbexpr.list_join(separator))
     end
 
@@ -457,7 +459,7 @@ def diff(n: 1, null_behavior: "ignore")
 
     # Shift values by the given period.
     #
-    # @param periods [Integer]
+    # @param n [Integer]
     #   Number of places to shift (may be negative).
     #
     # @return [Expr]
@@ -472,8 +474,9 @@ def diff(n: 1, null_behavior: "ignore")
     #   #         [null, 1, … 3]
     #   #         [null, 10, 2]
     #   # ]
-    def shift(periods = 1)
-      Utils.wrap_expr(_rbexpr.list_shift(periods))
+    def shift(n = 1)
+      n = Utils.parse_as_expression(n)
+      Utils.wrap_expr(_rbexpr.list_shift(n))
     end
 
     # Slice every sublist.
diff --git a/lib/polars/name_expr.rb b/lib/polars/name_expr.rb
new file mode 100644
index 0000000000..c8cbe096cd
--- /dev/null
+++ b/lib/polars/name_expr.rb
@@ -0,0 +1,198 @@
+module Polars
+  # Namespace for expressions that operate on expression names.
+  class NameExpr
+    # @private
+    attr_accessor :_rbexpr
+
+    # @private
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    # Keep the original root name of the expression.
+    #
+    # @note
+    #   Due to implementation constraints, this method can only be called as the last
+    #   expression in a chain.
+    #
+    # @return [Expr]
+    #
+    # @example Prevent errors due to potential duplicate column names.
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2],
+    #       "b" => [3, 4]
+    #     }
+    #   )
+    #   df.select((Polars.lit(10) / Polars.all).name.keep)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌──────┬──────────┐
+    #   # │ a    ┆ b        │
+    #   # │ ---  ┆ ---      │
+    #   # │ f64  ┆ f64      │
+    #   # ╞══════╪══════════╡
+    #   # │ 10.0 ┆ 3.333333 │
+    #   # │ 5.0  ┆ 2.5      │
+    #   # └──────┴──────────┘
+    #
+    # @example Undo an alias operation.
+    #   df.with_columns((Polars.col("a") * 9).alias("c").name.keep)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ a   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 9   ┆ 3   │
+    #   # │ 18  ┆ 4   │
+    #   # └─────┴─────┘
+    def keep
+      Utils.wrap_expr(_rbexpr.name_keep)
+    end
+
+    # Rename the output of an expression by mapping a function over the root name.
+    #
+    # @return [Expr]
+    #
+    # @example Remove a common suffix and convert to lower case.
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "A_reverse" => [3, 2, 1],
+    #       "B_reverse" => ["z", "y", "x"]
+    #     }
+    #   )
+    #   df.with_columns(
+    #     Polars.all.reverse.name.map { |c| c.delete_suffix("_reverse").downcase }
+    #   )
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌───────────┬───────────┬─────┬─────┐
+    #   # │ A_reverse ┆ B_reverse ┆ a   ┆ b   │
+    #   # │ ---       ┆ ---       ┆ --- ┆ --- │
+    #   # │ i64       ┆ str       ┆ i64 ┆ str │
+    #   # ╞═══════════╪═══════════╪═════╪═════╡
+    #   # │ 3         ┆ z         ┆ 1   ┆ x   │
+    #   # │ 2         ┆ y         ┆ 2   ┆ y   │
+    #   # │ 1         ┆ x         ┆ 3   ┆ z   │
+    #   # └───────────┴───────────┴─────┴─────┘
+    def map(&f)
+      Utils.wrap_expr(_rbexpr.name_map(f))
+    end
+
+    # Add a prefix to the root column name of the expression.
+    #
+    # @param prefix [Object]
+    #   Prefix to add to the root column name.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, 3],
+    #       "b" => ["x", "y", "z"]
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.reverse.name.prefix("reverse_"))
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌─────┬─────┬───────────┬───────────┐
+    #   # │ a   ┆ b   ┆ reverse_a ┆ reverse_b │
+    #   # │ --- ┆ --- ┆ ---       ┆ ---       │
+    #   # │ i64 ┆ str ┆ i64       ┆ str       │
+    #   # ╞═════╪═════╪═══════════╪═══════════╡
+    #   # │ 1   ┆ x   ┆ 3         ┆ z         │
+    #   # │ 2   ┆ y   ┆ 2         ┆ y         │
+    #   # │ 3   ┆ z   ┆ 1         ┆ x         │
+    #   # └─────┴─────┴───────────┴───────────┘
+    def prefix(prefix)
+      Utils.wrap_expr(_rbexpr.name_prefix(prefix))
+    end
+
+    # Add a suffix to the root column name of the expression.
+    #
+    # @param suffix [Object]
+    #   Suffix to add to the root column name.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, 3],
+    #       "b" => ["x", "y", "z"]
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.reverse.name.suffix("_reverse"))
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌─────┬─────┬───────────┬───────────┐
+    #   # │ a   ┆ b   ┆ a_reverse ┆ b_reverse │
+    #   # │ --- ┆ --- ┆ ---       ┆ ---       │
+    #   # │ i64 ┆ str ┆ i64       ┆ str       │
+    #   # ╞═════╪═════╪═══════════╪═══════════╡
+    #   # │ 1   ┆ x   ┆ 3         ┆ z         │
+    #   # │ 2   ┆ y   ┆ 2         ┆ y         │
+    #   # │ 3   ┆ z   ┆ 1         ┆ x         │
+    #   # └─────┴─────┴───────────┴───────────┘
+    def suffix(suffix)
+      Utils.wrap_expr(_rbexpr.name_suffix(suffix))
+    end
+
+    # Make the root column name lowercase.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "ColX" => [1, 2, 3],
+    #       "ColY" => ["x", "y", "z"],
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.name.to_lowercase)
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌──────┬──────┬──────┬──────┐
+    #   # │ ColX ┆ ColY ┆ colx ┆ coly │
+    #   # │ ---  ┆ ---  ┆ ---  ┆ ---  │
+    #   # │ i64  ┆ str  ┆ i64  ┆ str  │
+    #   # ╞══════╪══════╪══════╪══════╡
+    #   # │ 1    ┆ x    ┆ 1    ┆ x    │
+    #   # │ 2    ┆ y    ┆ 2    ┆ y    │
+    #   # │ 3    ┆ z    ┆ 3    ┆ z    │
+    #   # └──────┴──────┴──────┴──────┘
+    def to_lowercase
+      Utils.wrap_expr(_rbexpr.name_to_lowercase)
+    end
+
+    # Make the root column name uppercase.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "ColX" => [1, 2, 3],
+    #       "ColY" => ["x", "y", "z"]
+    #     }
+    #   )
+    #   df.with_columns(Polars.all.name.to_uppercase)
+    #   # =>
+    #   # shape: (3, 4)
+    #   # ┌──────┬──────┬──────┬──────┐
+    #   # │ ColX ┆ ColY ┆ COLX ┆ COLY │
+    #   # │ ---  ┆ ---  ┆ ---  ┆ ---  │
+    #   # │ i64  ┆ str  ┆ i64  ┆ str  │
+    #   # ╞══════╪══════╪══════╪══════╡
+    #   # │ 1    ┆ x    ┆ 1    ┆ x    │
+    #   # │ 2    ┆ y    ┆ 2    ┆ y    │
+    #   # │ 3    ┆ z    ┆ 3    ┆ z    │
+    #   # └──────┴──────┴──────┴──────┘
+    def to_uppercase
+      Utils.wrap_expr(_rbexpr.name_to_uppercase)
+    end
+  end
+end
diff --git a/lib/polars/series.rb b/lib/polars/series.rb
index 0c8c5186a4..8b81c466f5 100644
--- a/lib/polars/series.rb
+++ b/lib/polars/series.rb
@@ -3109,7 +3109,7 @@ def sample(
     #   s.peak_max
     #   # =>
     #   # shape: (5,)
-    #   # Series: '' [bool]
+    #   # Series: 'a' [bool]
     #   # [
     #   #         false
     #   #         false
@@ -3118,7 +3118,7 @@ def sample(
     #   #         true
     #   # ]
     def peak_max
-      Utils.wrap_s(_s.peak_max)
+      super
     end
 
     # Get a boolean mask of the local minimum peaks.
@@ -3130,7 +3130,7 @@ def peak_max
     #   s.peak_min
     #   # =>
     #   # shape: (5,)
-    #   # Series: '' [bool]
+    #   # Series: 'a' [bool]
     #   # [
     #   #         false
     #   #         true
@@ -3139,7 +3139,7 @@ def peak_max
     #   #         false
     #   # ]
     def peak_min
-      Utils.wrap_s(_s.peak_min)
+      super
     end
 
     # Count the number of unique values in this Series.
@@ -3223,13 +3223,13 @@ def reinterpret(signed: true)
     #   s.interpolate
     #   # =>
     #   # shape: (5,)
-    #   # Series: 'a' [i64]
+    #   # Series: 'a' [f64]
     #   # [
-    #   #         1
-    #   #         2
-    #   #         3
-    #   #         4
-    #   #         5
+    #   #         1.0
+    #   #         2.0
+    #   #         3.0
+    #   #         4.0
+    #   #         5.0
     #   # ]
     def interpolate(method: "linear")
       super
diff --git a/lib/polars/string_expr.rb b/lib/polars/string_expr.rb
index 21a1bd1595..ff0afb0e71 100644
--- a/lib/polars/string_expr.rb
+++ b/lib/polars/string_expr.rb
@@ -240,7 +240,7 @@ def strptime(dtype, format = nil, strict: true, exact: true, cache: true, utc: f
     #   # │ 東京 ┆ 6      ┆ 2      │
     #   # └──────┴────────┴────────┘
     def lengths
-      Utils.wrap_expr(_rbexpr.str_lengths)
+      Utils.wrap_expr(_rbexpr.str_len_bytes)
     end
 
     # Get length of the strings as `:u32` (as number of chars).
@@ -272,7 +272,7 @@ def lengths
     #   # │ 東京 ┆ 6      ┆ 2      │
     #   # └──────┴────────┴────────┘
     def n_chars
-      Utils.wrap_expr(_rbexpr.str_n_chars)
+      Utils.wrap_expr(_rbexpr.str_len_chars)
     end
 
     # Vertically concat the values in the Series to a single string value.
@@ -342,7 +342,7 @@ def to_lowercase
 
     # Remove leading and trailing whitespace.
     #
-    # @param matches [String, nil]
+    # @param characters [String, nil]
     #   An optional single character that should be trimmed.
     #
     # @return [Expr]
@@ -361,17 +361,15 @@ def to_lowercase
     #   # │ trail │
     #   # │ both  │
     #   # └───────┘
-    def strip_chars(matches = nil)
-      if !matches.nil? && matches.length > 1
-        raise ArgumentError, "matches should contain a single character"
-      end
-      Utils.wrap_expr(_rbexpr.str_strip_chars(matches))
+    def strip_chars(characters = nil)
+      characters = Utils.parse_as_expression(characters, str_as_lit: true)
+      Utils.wrap_expr(_rbexpr.str_strip_chars(characters))
     end
     alias_method :strip, :strip_chars
 
     # Remove leading whitespace.
     #
-    # @param matches [String, nil]
+    # @param characters [String, nil]
     #   An optional single character that should be trimmed.
     #
     # @return [Expr]
@@ -390,17 +388,15 @@ def strip_chars(matches = nil)
     #   # │ trail  │
     #   # │ both   │
     #   # └────────┘
-    def strip_chars_start(matches = nil)
-      if !matches.nil? && matches.length > 1
-        raise ArgumentError, "matches should contain a single character"
-      end
-      Utils.wrap_expr(_rbexpr.str_strip_chars_start(matches))
+    def strip_chars_start(characters = nil)
+      characters = Utils.parse_as_expression(characters, str_as_lit: true)
+      Utils.wrap_expr(_rbexpr.str_strip_chars_start(characters))
     end
     alias_method :lstrip, :strip_chars_start
 
     # Remove trailing whitespace.
     #
-    # @param matches [String, nil]
+    # @param characters [String, nil]
     #   An optional single character that should be trimmed.
     #
     # @return [Expr]
@@ -419,11 +415,9 @@ def strip_chars_start(matches = nil)
     #   # │ trail │
     #   # │  both │
     #   # └───────┘
-    def strip_chars_end(matches = nil)
-      if !matches.nil? && matches.length > 1
-        raise ArgumentError, "matches should contain a single character"
-      end
-      Utils.wrap_expr(_rbexpr.str_strip_chars_end(matches))
+    def strip_chars_end(characters = nil)
+      characters = Utils.parse_as_expression(characters, str_as_lit: true)
+      Utils.wrap_expr(_rbexpr.str_strip_chars_end(characters))
     end
     alias_method :rstrip, :strip_chars_end
 
@@ -469,13 +463,13 @@ def zfill(alignment)
       Utils.wrap_expr(_rbexpr.str_zfill(alignment))
     end
 
-    # Return the string left justified in a string of length `width`.
+    # Return the string left justified in a string of length `length`.
     #
     # Padding is done using the specified `fillchar`.
-    # The original string is returned if `width` is less than or equal to
+    # The original string is returned if `length` is less than or equal to
     # `s.length`.
     #
-    # @param width [Integer]
+    # @param length [Integer]
     #   Justify left to this length.
     # @param fillchar [String]
     #   Fill with this ASCII character.
@@ -497,17 +491,18 @@ def zfill(alignment)
     #   # │ null         │
     #   # │ hippopotamus │
     #   # └──────────────┘
-    def ljust(width, fillchar = " ")
-      Utils.wrap_expr(_rbexpr.str_ljust(width, fillchar))
+    def ljust(length, fillchar = " ")
+      Utils.wrap_expr(_rbexpr.str_pad_end(length, fillchar))
     end
+    alias_method :pad_end, :ljust
 
-    # Return the string right justified in a string of length `width`.
+    # Return the string right justified in a string of length `length`.
     #
     # Padding is done using the specified `fillchar`.
-    # The original string is returned if `width` is less than or equal to
+    # The original string is returned if `length` is less than or equal to
     # `s.length`.
     #
-    # @param width [Integer]
+    # @param length [Integer]
     #   Justify right to this length.
     # @param fillchar [String]
     #   Fill with this ASCII character.
@@ -529,9 +524,10 @@ def ljust(width, fillchar = " ")
     #   # │ null         │
     #   # │ hippopotamus │
     #   # └──────────────┘
-    def rjust(width, fillchar = " ")
-      Utils.wrap_expr(_rbexpr.str_rjust(width, fillchar))
+    def rjust(length, fillchar = " ")
+      Utils.wrap_expr(_rbexpr.str_pad_start(length, fillchar))
     end
+    alias_method :pad_start, :rjust
 
     # Check if string contains a substring that matches a regex.
     #
@@ -945,6 +941,7 @@ def split(by, inclusive: false)
     #   # │ {"d","4"}   │
     #   # └─────────────┘
     def split_exact(by, n, inclusive: false)
+      by = Utils.parse_as_expression(by, str_as_lit: true)
       if inclusive
         Utils.wrap_expr(_rbexpr.str_split_exact_inclusive(by, n))
       else
@@ -981,6 +978,7 @@ def split_exact(by, n, inclusive: false)
     #   # │ {"foo","bar baz"} │
     #   # └───────────────────┘
     def splitn(by, n)
+      by = Utils.parse_as_expression(by, str_as_lit: true)
       Utils.wrap_expr(_rbexpr.str_splitn(by, n))
     end
 
diff --git a/test/docs_test.rb b/test/docs_test.rb
index 66f146d42a..b919d72f5f 100644
--- a/test/docs_test.rb
+++ b/test/docs_test.rb
@@ -85,6 +85,10 @@ def test_meta_expr
     assert_docs Polars::MetaExpr
   end
 
+  def test_name_expr
+    assert_docs Polars::NameExpr
+  end
+
   def test_series
     assert_docs Polars::Series
   end
diff --git a/test/types_test.rb b/test/types_test.rb
index ecd5cde891..e989e5e1ed 100644
--- a/test/types_test.rb
+++ b/test/types_test.rb
@@ -144,7 +144,7 @@ def test_series_dtype_array_incompatible_width
     error = assert_raises do
       Polars::Series.new([[1, 2], [3, 4]], dtype: Polars::Array.new(3, Polars::Int64))
     end
-    assert_equal "Invalid argument error: incompatible offsets in source list", error.message
+    assert_equal "incompatible offsets in source list", error.message
   end
 
   def test_series_dtype_struct