diff --git a/src/index.js b/src/index.js
index 8ffbf472fe..590d219c8d 100644
--- a/src/index.js
+++ b/src/index.js
@@ -92,7 +92,7 @@ export { default as isNaturalNumber } from './isNaturalNumber';
 export { default as isPrimitive } from './isPrimitive';
 export { default as isNotPrimitive } from './isNotPrimitive';
 export { default as isSentinelValue } from './isSentinelValue';
-export { default as isBlank } from './isBlank';
+export { default as isBlank } from './internal/isBlank';
 // Function
 export { default as stubUndefined } from './stubUndefined';
 export { default as stubNull } from './stubNull';
@@ -197,6 +197,7 @@ export { default as inRange } from './inRange';
 export { default as notEqual } from './notEqual';
 export { default as overlaps } from './overlaps';
 // Logic
+export { default as presence } from './presence';
 export { default as isNotEmpty } from './isNotEmpty';
 export { default as defaultWhen } from './defaultWhen';
 export { default as notBoth } from './notBoth';
diff --git a/src/isBlank.js b/src/internal/isBlank.js
similarity index 97%
rename from src/isBlank.js
rename to src/internal/isBlank.js
index 78d4c99f7a..80d590fbc1 100644
--- a/src/isBlank.js
+++ b/src/internal/isBlank.js
@@ -1,6 +1,6 @@
 import { isEmpty, isNil, anyPass, test } from 'ramda';
 
-import isFalse from './isFalse';
+import isFalse from '../isFalse';
 /**
  * Returns `true` if the given value is its type's empty value, `false`, `undefined`
  * as well as strings containing only whitespace characters; `false` otherwise.
diff --git a/src/presence.js b/src/presence.js
new file mode 100644
index 0000000000..9f2914af0a
--- /dev/null
+++ b/src/presence.js
@@ -0,0 +1,41 @@
+import * as R from 'ramda';
+
+import isBlank from './internal/isBlank';
+
+/**
+ * Returns the receiver if it’s present, otherwise returns `null`.
+ *
+ * @func presence
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/3.2.0|v3.2.0}
+ * @category Logic
+ * @sig a -> a | null
+ * @see {@link http://ramdajs.com/docs/#isEmpty|R.isEmpty}
+ * @param {*} val The value to test
+ * @return {*}
+ * @example
+ *
+ * RA.presence({ foo: 'foo' }) // => { foo: 'foo' }
+ * RA.presence({}) // => null
+ * RA.presence(false) // => null
+ * RA.presence(true) // => true
+ * RA.presence('') // => null
+ * RA.presence('  ') // => null
+ * RA.presence('\t\n') // => null
+ * RA.presence('foo') // => foo
+ * RA.presence([]) // => null
+ * RA.presence([1, 2, 3]) // => [1, 2, 3]
+ * RA.presence(undefined) // => null
+ * RA.presence(0) // => 0
+ * RA.presence(null) // => null
+ */
+
+const presence = R.cond([
+  [R.equals(false), R.always(null)],
+  [isBlank, R.always(null)],
+  [R.isEmpty, R.always(null)],
+  [R.isNil, R.always(null)],
+  [R.T, R.identity],
+]);
+
+export default presence;
diff --git a/test/internal/isBlank.js b/test/internal/isBlank.js
new file mode 100644
index 0000000000..38e6034996
--- /dev/null
+++ b/test/internal/isBlank.js
@@ -0,0 +1,28 @@
+import { assert } from 'chai';
+import * as R from 'ramda';
+
+import { isBlank } from '../../src';
+
+describe('isBlank', function () {
+  it('should test value for a `Blank`', function () {
+    assert.isTrue(isBlank(''));
+    assert.isTrue(isBlank('   '));
+    assert.isTrue(isBlank('\t\n'));
+    assert.isTrue(isBlank({}));
+    assert.isTrue(isBlank(null));
+    assert.isTrue(isBlank(undefined));
+    assert.isTrue(isBlank([]));
+    assert.isTrue(isBlank(false));
+
+    assert.isFalse(isBlank('value'));
+    assert.isFalse(isBlank({ foo: 'foo' }));
+    assert.isFalse(isBlank([1, 2, 3]));
+    assert.isFalse(isBlank(true));
+  });
+
+  it('should support placeholder to specify "gaps"', function () {
+    const _isBlank = isBlank(R.__);
+
+    assert.isTrue(_isBlank(''));
+  });
+});
diff --git a/test/isBlank.js b/test/isBlank.js
deleted file mode 100644
index 123ec77f82..0000000000
--- a/test/isBlank.js
+++ /dev/null
@@ -1,28 +0,0 @@
-import { assert } from 'chai';
-import * as R from 'ramda';
-
-import * as RA from '../src';
-
-describe('isBlank', function () {
-  it('should test value for a `Blank`', function () {
-    assert.isTrue(RA.isBlank(''));
-    assert.isTrue(RA.isBlank('   '));
-    assert.isTrue(RA.isBlank('\t\n'));
-    assert.isTrue(RA.isBlank({}));
-    assert.isTrue(RA.isBlank(null));
-    assert.isTrue(RA.isBlank(undefined));
-    assert.isTrue(RA.isBlank([]));
-    assert.isTrue(RA.isBlank(false));
-
-    assert.isFalse(RA.isBlank('value'));
-    assert.isFalse(RA.isBlank({ foo: 'foo' }));
-    assert.isFalse(RA.isBlank([1, 2, 3]));
-    assert.isFalse(RA.isBlank(true));
-  });
-
-  it('should support placeholder to specify "gaps"', function () {
-    const isBlank = RA.isBlank(R.__);
-
-    assert.isTrue(isBlank(''));
-  });
-});
diff --git a/test/presence.js b/test/presence.js
new file mode 100644
index 0000000000..802935a990
--- /dev/null
+++ b/test/presence.js
@@ -0,0 +1,93 @@
+import { assert } from 'chai';
+
+import * as RA from '../src';
+
+describe('presence', function () {
+  context('given an object', function () {
+    specify('should return the object', function () {
+      const val = { foo: 'foo' };
+
+      assert.strictEqual(RA.presence(val), val);
+    });
+  });
+
+  context('given an empty object', function () {
+    specify('should return null', function () {
+      const val = {};
+
+      assert.strictEqual(RA.presence(val), null);
+    });
+  });
+
+  context('given a boolean with value false', function () {
+    specify('should return null', function () {
+      const val = false;
+
+      assert.strictEqual(RA.presence(val), null);
+    });
+  });
+
+  context('given a boolean with value true', function () {
+    specify('should return boolean true', function () {
+      const val = true;
+
+      assert.strictEqual(RA.presence(val), val);
+    });
+  });
+
+  context('given an empty string', function () {
+    specify('should return null', function () {
+      assert.strictEqual(RA.presence(''), null);
+      assert.strictEqual(RA.presence('   '), null);
+      assert.strictEqual(RA.presence('\t\n'), null);
+    });
+  });
+
+  context('given a string', function () {
+    specify('should return the correct string', function () {
+      const val = 'val';
+
+      assert.strictEqual(RA.presence(val), val);
+    });
+  });
+
+  context('given an empty array', function () {
+    specify('should return null', function () {
+      const val = [];
+
+      assert.strictEqual(RA.presence(val), null);
+    });
+  });
+
+  context('given an array with values', function () {
+    specify('should return the array', function () {
+      const val = [1, 2, 3];
+
+      assert.strictEqual(RA.presence(val), val);
+    });
+  });
+
+  context('given an undefined', function () {
+    specify('should return null', function () {
+      const val = undefined;
+
+      assert.strictEqual(RA.presence(val), null);
+    });
+  });
+
+  context('given a number', function () {
+    specify('should return number', function () {
+      const val = 0;
+
+      assert.strictEqual(RA.presence(val), val);
+    });
+  });
+
+  context('given a null', function () {
+    specify('should return null', function () {
+      const val = null;
+
+      assert.strictEqual(RA.presence(val), val);
+    });
+  });
+});