diff --git a/context_slog.go b/context_slog.go
index 1340c6b..5b1b7b6 100644
--- a/context_slog.go
+++ b/context_slog.go
@@ -36,7 +36,7 @@ func FromContext(ctx context.Context) (Logger, error) {
 	case Logger:
 		return v, nil
 	case *slog.Logger:
-		return NewLogr(v.Handler()), nil
+		return NewFromSlogHandler(v.Handler()), nil
 	default:
 		// Not reached.
 		panic(fmt.Sprintf("unexpected value type for logr context key: %T", v))
diff --git a/slogr.go b/slogr.go
index c0a3bbd..7125c25 100644
--- a/slogr.go
+++ b/slogr.go
@@ -24,11 +24,11 @@ import (
 	"log/slog"
 )
 
-// NewLogr returns a Logger which writes to the slog.Handler.
+// NewFromSlogHandler returns a Logger which writes to the slog.Handler.
 //
 // The logr verbosity level is mapped to slog levels such that V(0) becomes
 // slog.LevelInfo and V(4) becomes slog.LevelDebug.
-func NewLogr(handler slog.Handler) Logger {
+func NewFromSlogHandler(handler slog.Handler) Logger {
 	if handler, ok := handler.(*slogHandler); ok {
 		if handler.sink == nil {
 			return Discard()
diff --git a/slogr/slogr.go b/slogr/slogr.go
index 66671a8..b34769c 100644
--- a/slogr/slogr.go
+++ b/slogr/slogr.go
@@ -36,7 +36,7 @@ import (
 // The logr verbosity level is mapped to slog levels such that V(0) becomes
 // slog.LevelInfo and V(4) becomes slog.LevelDebug.
 func NewLogr(handler slog.Handler) logr.Logger {
-	return logr.NewLogr(handler)
+	return logr.NewFromSlogHandler(handler)
 }
 
 // NewSlogHandler returns a slog.Handler which writes to the same sink as the logr.Logger.
diff --git a/slogr_test.go b/slogr_test.go
index d37a9bf..d709e76 100644
--- a/slogr_test.go
+++ b/slogr_test.go
@@ -48,8 +48,8 @@ var debugWithoutTime = &slog.HandlerOptions{
 	Level: slog.LevelDebug,
 }
 
-func ExampleNew() {
-	logrLogger := logr.NewLogr(slog.NewTextHandler(os.Stdout, debugWithoutTime))
+func ExampleNewFromSlogHandler() {
+	logrLogger := logr.NewFromSlogHandler(slog.NewTextHandler(os.Stdout, debugWithoutTime))
 
 	logrLogger.Info("hello world")
 	logrLogger.Error(errors.New("fake error"), "ignore me")
@@ -91,7 +91,7 @@ func TestWithCallDepth(t *testing.T) {
 	debugWithCaller := *debugWithoutTime
 	debugWithCaller.AddSource = true
 	var buffer bytes.Buffer
-	logger := logr.NewLogr(slog.NewTextHandler(&buffer, &debugWithCaller))
+	logger := logr.NewFromSlogHandler(slog.NewTextHandler(&buffer, &debugWithCaller))
 
 	logHelper(logger)
 	_, file, line, _ := runtime.Caller(0)
@@ -228,22 +228,22 @@ func TestDiscard(t *testing.T) {
 
 func TestConversion(t *testing.T) {
 	d := logr.Discard()
-	d2 := logr.NewLogr(logr.NewSlogHandler(d))
+	d2 := logr.NewFromSlogHandler(logr.NewSlogHandler(d))
 	expectEqual(t, d, d2)
 
 	e := logr.Logger{}
-	e2 := logr.NewLogr(logr.NewSlogHandler(e))
+	e2 := logr.NewFromSlogHandler(logr.NewSlogHandler(e))
 	expectEqual(t, e, e2)
 
 	f := funcr.New(func(prefix, args string) {}, funcr.Options{})
-	f2 := logr.NewLogr(logr.NewSlogHandler(f))
+	f2 := logr.NewFromSlogHandler(logr.NewSlogHandler(f))
 	expectEqual(t, f, f2)
 
 	text := slog.NewTextHandler(io.Discard, nil)
-	text2 := logr.NewSlogHandler(logr.NewLogr(text))
+	text2 := logr.NewSlogHandler(logr.NewFromSlogHandler(text))
 	expectEqual(t, text, text2)
 
-	text3 := logr.NewSlogHandler(logr.NewLogr(text).V(1))
+	text3 := logr.NewSlogHandler(logr.NewFromSlogHandler(text).V(1))
 	if handler, ok := text3.(interface {
 		GetLevel() slog.Level
 	}); ok {
diff --git a/slogsink.go b/slogsink.go
index 44d4c04..93fa4e5 100644
--- a/slogsink.go
+++ b/slogsink.go
@@ -32,7 +32,7 @@ var (
 	_ Underlier        = &slogSink{}
 )
 
-// Underlier is implemented by the LogSink returned by NewLogr.
+// Underlier is implemented by the LogSink returned by NewFromLogHandler.
 type Underlier interface {
 	// GetUnderlying returns the Handler used by the LogSink.
 	GetUnderlying() slog.Handler