Build list chunks consisting in substrings of input string s, separated by one or more space characters.
New implementation

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating material.

Please try to avoid dependencies to third-party libraries and frameworks.

Other implementations
#include <string.h>
chunks[0] = strtok(s, " ");
for (int i = 1; i < N; ++i)
    chunks[i] = strtok(NULL, " ");
    if (!chunks[i])
(require '[clojure.string :refer [split]])
(def chunks (split s #"\s+"))
#include <sstream>
#include <algorithm>
#include <iterator>
#include <list>
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));
string[] chunks = s.Split(' ');
import std.range;
auto chunks = s.splitter;
s.split(new RegExp('\\s+'))
chunks = String.split(s)
Chunks = string:tokens(S, [$\s]).
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)
end program main
import "strings"
chunks := strings.Split(s, " ")
import "strings"
chunks := strings.Fields(s)
def chunks = s.split(/\s+/)
chunks = words s
let chunks = s.split(/ +/);
String[] chunks = s.split("\\s+");
val chunks = s.split("\\s+".toRegex())
chunks = {}
for substring in s:gmatch("%S+") do
   table.insert(chunks, substring)
@import Foundation;
NSArray *chunks=[s componentsSeparatedByString:@" "];
$chunks = preg_split('/ +/', $s);
Uses Classes;
chunks.StrictDelimiter := True;
chunks.Delimiter := ' ';
chunks.DelimitedText := s;
@chunks = split /\s+/, $s;
chunks = s.split()
chunks = s.split
let chunks: Vec<_> = s.split_ascii_whitespace().collect();
let chunks: Vec<_> = s.split_whitespace().collect();
let chunks: Vec<_> = s.split(' ').collect();
val chunks = s.split(" ")
(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))))
chunks := s substrings