Yes you can, but instead of blank, simply return null if you don't want to render anything from component, like this:

return (null);

Another important point is, inside JSX if you are rendering element conditionally, then in case of condition=false, you can return any of these values false, null, undefined, true. As per DOC:

booleans (true/false), null, and undefined are valid children, they will be Ignored means they simply don’t render.

All these JSX expressions will render to the same thing:

<div />

<div></div>

<div>{false}</div>

<div>{null}</div>

<div>{undefined}</div>

<div>{true}</div>

Example:

Only odd values will get rendered, because for even values we are returning null.

const App = ({ number }) => {
  if(number%2) {
    return (
      <div>
        Number: {number}
      </div>
    )
  }
  
  return (null);           //===> notice here, returning null for even values
}

const data = [1,2,3,4,5,6];

ReactDOM.render(
  <div>
    {data.map(el => <App key={el} number={el} />)}
  </div>,
  document.getElementById('app')
)

<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.1.0/react-dom.min.js"></script>

<div id='app' />

The problem here is about arrow functions, when you want to return value without the return keyword, the body of your function should be wrapped with () not {}, like this:

export const Parent = () => (
     <SmallModal
            className='parent-modal'
            isOpen={true}
        >
            <BodyGrey>
                <header className='equip-modal-header'>
                    Practising React
                </header>
                <div>
                    <p>This is a functional component without return keyword.</p>
                </div>                
            </BodyGrey>
        </SmallModal>
)

As of React 15.0, you can return null from a stateless functional component. (See #5355). No more having to return <noscript />

The change that made this possible is that React removed support for component classes that don’t inherit from React.Component, meaning they can reliably differentiate between React components (classes that inherit React.Component) and functional stateless components. So the PR to enable the functionality just involved removing and simplifying the code that instantiates the components.

Prematurely using useCallback to optimise can often lead to worse performance. It is recommended to only start using it when you have a measurable performance issue, so you can test whether the overhead of useCallback is worth the memoization it brings.

Also, in your example code, because the dependency array at the end is empty, it will always return the same value, as useCallback works by only re-running the given function when a variable in that array has changed.

This is what I would do:

const HelloWorld = () => {
  const getHelloWorldText = () => {
    return "HelloWorld"
  }

  return <>{getHelloWorldText()}</>
}

As of React >= 16.2 it is possible to use any of these versions:

render() { 
   return false; 
}

render() { 
   return null; 
}

render() { 
   return []; 
}

render() { 
   return <React.Fragment></React.Fragment>; 
}

render() { 
   return <></>; 
}

Returning undefined does not work.

The component I'm thinking of is something that you pass some data to, and it'll send data back to a javascript function outside of react.

Why would you want to create a component for that? Most of the time a regular js function in an existing component can be enough.

One usecase is for exemple to setup a side-effect when component is mounted and tear it down when it unmounts. For exemple if you have a ReactNative mobile app with portrait orientation, you could imagine a <Landscape/> component, that, when mounted, would allow temporarily to display the app in landscape orientation, and when unmounted, orientation would be reset to app default. You can surely manage this orientation change on an existing component, but creating a dedicated component might be more handy and reusable.

Note that React can also run on the server side so I guess it is possible to use it in such a way that it doesn't involve any DOM modifications (but maybe only the virtual DOM computation).