• Dart

s.split(new RegExp('\\s+'))

• C

chunks[0] = strtok(s, " ");
for (int i = 1; i < N; ++i)
{
    chunks[i] = strtok(NULL, " ");
    
    if (!chunks[i])
        break;
}

• Clojure

(def chunks (split s #"\s+"))

• C++

std::istringstream x(s);
std::list<std::string> chunks;
std::copy(std::istream_iterator<std::string>(x), std::istream_iterator<std::string>(), std::back_inserter(chunks));

• C#

string[] chunks = s.Split(' ');

• D

auto chunks = s.splitter;

• Elixir

chunks = String.split(s)

• Erlang

Chunks = string:tokens(S, [$\s]).

• Fortran

program main
use stringifor_string_t ! https://github.com/szaghi/StringiFor
   implicit none
   type( string ) ::  string1
   type( string ), allocatable :: substrings( : )
   integer :: i

   string1 =  " Build list _chunks consisting in substrings of input string _s  separated by one or more space characters"
   call string1%split(sep=' ', tokens=substrings )
   do i=1,size(substrings, dim=1)
   write(*,*) substrings(i)
   enddo
end program main

• Go

chunks := strings.Split(s, " ")

• Go

chunks := strings.Fields(s)

• Groovy

def chunks = s.split(/\s+/)

• Haskell

chunks = words s

• JS

let chunks = s.split(/ +/);

• Java

String[] chunks = s.split("\\s+");

• Lua

chunks = {}
for substring in s:gmatch("%S+") do
   table.insert(chunks, substring)
end

• Obj-C

NSArray *chunks=[s componentsSeparatedByString:@" "];

• PHP

$chunks = preg_split('/ +/', $s);

• Pascal

chunks.StrictDelimiter := True;
chunks.Delimiter := ' ';
chunks.DelimitedText := s;

• Perl

@chunks = split /\s+/, $s;

• Python

chunks = s.split()

• Ruby

chunks = s.split

• Rust

let chunks:Vec<_> = s.split_whitespace().collect();

• Scala

val chunks = s.split(" ")

• Scheme

(define (tokenize l)
  (let loop ((t '())
             (l l))
    (if (pair? l)
        (let ((c (car l)))
          (if (char=? c #\space)
              (cons (reverse t) (loop '() (cdr l)))
              (loop (cons (car l) t) (cdr l))))
        (if (null? t)
            '()
            (list (reverse t))))))

(define (string-split s)
  (map list->string (tokenize (string->list s))))