Flatten a list: Difference between revisions

 

=={{header|8th}}==

\ take a list (array) and flatten it:

 

. cr

bye

{{out}}

[[1],2,[[3,4],5],[[[]]],[[[6]]],7,8,[]]<br>

 

=={{header|ACL2}}==

(cond ((null tr) nil)

((atom tr) (list tr))

(t (append (flatten (first tr))

 

=={{header|ActionScript}}==

var output:Array = new Array();

for (var i:uint = 0; i < input.length; i++) {

return output;

}

 

=={{header|Ada}}==

nestable_lists.ads:

type Element_Type is private;

with function To_String (E : Element_Type) return String is <>;

function To_String (L : List) return String;

nestable_lists.adb:

 

package body Nestable_Lists is

end To_String;

 

example usage:

with Nestable_Lists;

 

Ada.Text_IO.Put_Line (Int_List.To_String (Flattened));

end;

Output:

<pre>[[ 1], 2, [[ 3, 4], 5], [[[]]], [[[ 6]]], 7, 8, []]

 

=={{header|Aikido}}==

function flatten (list, result) {

foreach item list {

println("]")

 

{{out}}

<pre>

 

=={{header|Aime}}==

show_list(list l)

{

 

return 0;

{{out}}

<pre>

Flattening is built in to all of Algol68's ''transput'' routines. The following example also uses ''widening'', where scalars are converted into arrays.

 

[][][]INT list = ((1), 2, ((3,4), 5), ((())), (((6))), 7, 8, ());

print((list, new line))

{{out}}

<pre>

+1 +2 +3 +4 +5 +6 +7 +8

</pre>

 

=={{header|AppleScript}}==

 

on my_flatten(aList)

end if

end my_flatten

 

 

Or, to make more productive use of the language (where "efficiency" is a function of the scripter's time, rather than the machine's) we can express this in terms of a generic '''concatMap''':

{{trans|JavaScript}}

on flatten(t)

if class of t is list then

end script

end if

{{Out}}

 

 

It can be more efficient to build just one list by appending items to it than to proliferate lists using concatenation:

 

script o

property flatList : {}

 

return o's flatList

 

=={{header|AutoHotkey}}==

AutoHotkey doesn't have built in list data type.

This examples simulates a list in a tree type object and flattens that tree.

, 2, 5), 4, object(1, object(1, object(1, object()))), 5

, object(1, object(1, 6)), 6, 7, 7, 8, 9, object())

}

return flat

 

BaCon has the concept of delimited strings, which may contain delimited strings within delimited strings etc. Such nested delimited strings must be surrounded by (escaped) double quotes in order to avoid their delimiter messing up operations on higher level delimited strings. However, from functional point of view, a delimited string is the same as a regular list. The special function FLATTEN$ can actually flatten out lists within lists. The last SORT$ in the program below makes sure no empty items remain in the list.

 

lst$ = "\"1\",2,\"\\\"3,4\\\",5\",\"\\\"\\\\\"\\\\\"\\\"\",\"\\\"\\\\\"6\\\\\"\\\"\",7,8,\"\""

UNTIL AMOUNT(lst$, ",") = AMOUNT(FLATTEN$(lst$), ",")

 

{{out}}

 

{{trans|FreeBASIC}}

sString = "[[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8 []]"

 

 

Print "["; sFlatter; "]"

{{out}}

<pre>

</pre>

 

=={{header|Bracmat}}==

A list that should not be flattened upon evaluation can be separated with dots.

 

( (myList = ((1), 2, ((3,4), 5), ((())), (((6))), 7, 8, ()))

& put$("Unevaluated:")

& lst$myList

)

 

=={{header|Brat}}==

true? my.empty?

{ [] }

list = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

p "List: #{list}"

 

=={{header|Burlesque}}==

until the Block does not contain Blocks anymore.

 

blsq ) {{1} 2 {{3 4} 5} {{{}}} {{{6}}} 7 8 {}}{\[}{)to{"Block"==}ay}w!

{1 2 3 4 5 6 7 8}

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

/* delete_list(l); delete_list(flat); */

return 0;

{{out}}

<pre>Nested: [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]

 

Actual Workhorse code

using System;

using System.Collections;

}

}

 

Method showing population of arraylist and usage of flatten method

using System;

using System.Collections;

}

 

 

{{works with|C sharp|C#|4+}}

 

public static class Ex {

public static List<object> Flatten(this List<object> list) {

}

}

 

=={{header|C++}}==

#include <boost/any.hpp>

 

++current;

}

 

Use example:

Also, there's no standard way to output this type of list,

so some output code is added as well.

#include <iostream>

 

print_list(list);

std::cout << "\n";

{{out}}

<pre>

 

=={{header|Ceylon}}==

"Lazily flatten nested streams"

{Anything*} flatten({Anything*} stream)

print(list);

print(flatten(list).sequence());

{{out}}

<pre>

=={{header|Clojure}}==

The following returns a lazy sequence of the flattened data structure.

(lazy-seq

(when-let [s (seq coll)]

(if (coll? (first s))

(concat (flatten (first s)) (flatten (rest s)))

 

The built-in flatten is implemented as:

 

(filter (complement sequential?)

 

=={{header|CoffeeScript}}==

flatten = (arr) ->

arr.reduce ((xs, el) ->

list = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

console.log flatten list

 

Ouput:

> coffee foo.coffee

[ 1, 2, 3, 4, 5, 6, 7, 8 ]

 

=={{header|Common Lisp}}==

 

(cond ((null structure) nil)

((atom structure) (list structure))

or, from Paul Graham's OnLisp,

(defun flatten (ls)

(labels ((mklist (x) (if (listp x) x (list x))))

(mapcan #'(lambda (x) (if (atom x) (mklist x) (flatten x))) ls)))

 

Note that since, in Common Lisp, the empty list, boolean false and <code>nil</code> are the same thing, a tree of <code>nil</code> values cannot be flattened; they will disappear.

 

A third version that is recursive, imperative, and reasonably fast.

(let (result)

(labels ((grep (obj)

(grep (first obj))))))

(grep obj)

 

The following version is tail recursive and functional.

(cond ((consp x) (flatten (rest x) (cons (first x) stack) out))

(x (flatten (first stack) (rest stack) (cons x out)))

(stack (flatten (first stack) (rest stack) out))

 

The next version is imperative, iterative and does not make use of a stack. It is faster than the versions given above.

(do* ((result (list obj))

(node result))

(when (cdar node) (push (cdar node) (cdr node)))

(setf (car node) (caar node)))

The above implementations of flatten give the same output on nested proper lists.

{{Out}}

 

=={{header|Crystal}}==

[[1], 2, [[3, 4], 5], [[[] of Int32]], [[[6]]], 7, 8, [] of Int32].flatten()

[1, 2, 3, 4, 5, 6, 7, 8]

 

=={{header|D}}==

Instead of a Java-like class-based version, this version minimizes heap activity using a tagged union.

 

struct TreeList(T) {

l.writeln;

l.flatten.writeln;

{{out}}

<pre>[[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]

===With an Algebraic Data Type===

A shorter and more cryptic version.

 

alias T = Algebraic!(int, This[]);

T( T[].init )

]).flatten.writeln;

{{out}}

[1, 2, 3, 4, 5, 6, 7, 8]

 

=={{header|Déjà Vu}}==

for i in copy:

i

 

 

{{out}}

<pre>[ 1 2 3 4 5 6 7 8 ]</pre>

=={{header|E}}==

 

def flat := [].diverge()

def recur(x) {

recur(nested)

return flat.snapshot()

 

 

=={{header|EchoLisp}}==

The built-in '''(flatten list)''' is defined as follows:

(define (fflatten l)

(cond

→ ((4) (5 5 5) (6 6) (7) (8) (7 7 7) (9))

 

 

=={{header|Ela}}==

This implementation can flattern any given list:

 

flat = flat' []

| else = x :: flat' n xs

 

 

{{out}}

An alternative solution:

 

flat (x::xs)

| x is List = flat x ++ flat xs

 

=={{header|Elixir}}==

defmodule RC do

def flatten([]), do: []

# Library function

IO.inspect List.flatten(list)

{{out}}

<pre>

=={{header|Elm}}==

 

import Graphics.Element exposing (show)

 

main =

show (flatten tree)

 

=={{header|Emacs Lisp}}==

(cond

((null mylist) nil)

((atom mylist) (list mylist))

(t

 

=={{header|Erlang}}==

There's a standard function (lists:flatten/1) that does it more efficiently, but this is the cleanest implementation you could have;

flatten([H|T]) -> flatten(H) ++ flatten(T);

 

=={{header|Euphoria}}==

{{works with|Euphoria|4.0.0}}

 

function flatten( object s )

 

? a

{{out}}

<pre>{

=={{header|F_Sharp|F#}}==

As with Haskell and OCaml we have to define our list as an algebraic data type, to be strongly typed:

| I of 'a // leaf Item

| L of 'a ll list // ' <- confine the syntax colouring confusion

printfn "%A" (flatten [L([I(1)]); I(2); L([L([I(3);I(4)]); I(5)]); L([L([L([])])]); L([L([L([I(6)])])]); I(7); I(8); L([])])

 

 

An alternative approach with List.collect

and the same data type. Note that flatten operates on all deepLists (ll) and atoms (I) are "flatened" to lists.

 

let rec flatten =

function

 

// -> [1; 2; 3; 4; 5; 6; 7; 8]

 

=={{header|Factor}}==

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|Forth}}==

Needs the FMS-SI (single inheritance) library code located here:

http://soton.mpeforth.com/flag/fms/index.html

include FMS-SILib.f

 

o{ o{ 1 } 2 o{ o{ 3 4 } 5 } o{ o{ o{ } } } o{ o{ o{ 6 } } } 7 8 o{ } }

list flatten

 

=={{header|Fortran}}==

 

! input : [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]

! flatten : [1, 2, 3, 4, 5, 6, 7, 8 ]

print *, "]"

end program

 

===Or, older style===

Fortran does not offer strings, only CHARACTER variables of some fixed size. Functions can return such types, but, must specify a fixed size. Or, mess about with run-time allocation as above. Since in principle a list is arbitrarily long, the plan here is to crush its content in place, and thereby never have to worry about long-enough work areas. This works because the transformations in mind never replace something by something longer. A subroutine can receive an arbitrary-sized CHARACTER variable, and can change it. No attempt is made to detect improper lists.

SUBROUTINE CRUSH(LIST) !Changes LIST.

Crushes a list holding multi-level entries within [...] to a list of single-level entries. Null entries are purged.

CALL CRUSH(STUFF) !Can't be a constant, as it will be changed.

WRITE (6,*) " Crushed: ",STUFF !Behold!

Output is

Original: [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

 

All of this relies on the list being presented as a flat text, which text is then manipulated directly. If the list was manifested in a data structure of some kind with links and suchlike, then tree-traversal of that structure would be needed to reach the leaf entries.

 

=={{header|Frink}}==

a = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

println[flatten[a]]

 

=={{header|GAP}}==

 

=={{header|GNU APL}}==

Using (monadic) enlist function ε. Sometimes called 'Super Ravel'.

⊢list←(2 3ρι6)(2 2ρ(7 8(2 2ρ9 10 11 12)13)) 'ABCD'

┏→━━━━━━━━━━━━━━━━━━━━━━━━━━┓

┃1 2 3 4 5 6 7 8 9 10 11 12 13 'A''B''C''D'┃

┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛

 

=={{header|Go}}==

 

import "fmt"

}

return

{{out}}

<pre>

In the code above, flatten uses an easy-to-read type switch to extract ints and return an int slice. The version below is generalized to return a flattened slice of interface{} type, which can of course refer to objects of any type, and not just int.

Also, just to show a variation in programming style, a type assertion is used rather than a type switch.

for _, e := range s {

if i, ok := e.([]interface{}); ok {

}

return

 

=={{header|Groovy}}==

<code>List.flatten()</code> is a Groovy built-in that returns a flattened copy of the source list:

 

 

=={{header|Haskell}}==

In Haskell we have to interpret this structure as an algebraic data type.

 

 

-- [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

 

main :: IO ()

{{Out}}

<pre>[1,2,3,4,5,6,7,8]</pre>

 

Alternately:

= Leaf a

| Node [Tree a]

]

 

Yet another choice, custom data structure, efficient lazy flattening:

(This is unnecessary; since Haskell is lazy, the previous solution will only do just as much work as necessary for each element that is requested from the resulting list.)

 

= NList [NestedList a]

| Entry a

main :: IO ()

main = print $ flatten example

 

=={{header|Hy}}==

(sum (genexpr (if (isinstance x list)

(flatten x)

 

(print (flatten [[1] 2 [[3 4] 5] [[[]]] [[[6]]] 7 8 []]))

 

=={{header|Icon}} and {{header|Unicon}}==

The following procedure solves the task using a string representation of nested lists and cares not if the list is well formed or not.

 

procedure sflatten(s) # uninteresting string solution

return pretrim(trim(compress(deletec(s,'[ ]'),',') ,','),',')

{{libheader|Icon Programming Library}}

The solution uses several procedures from [http://www.cs.arizona.edu/icon/library/src/procs/strings.icn strings in the IPL]

 

This procedure is more in the spirit of the task handling actual lists rather than representations. It uses a recursive approach using some of the built-in list manipulation functions and operators.

local l,x

 

else put(l,x)

return l

 

Finally a demo routine to drive these and a helper to show how it works.

write(sflatten(" [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]"))

writelist(flatten( [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]))

write(" ]")

return

 

=={{header|Ioke}}==

[[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []] flatten

 

=={{header|Isabelle}}==

 

imports Main

begin

by(simp add: example_def)

 

 

=={{header|J}}==

 

'''Solution''':

 

'''Example''':

]li =. (<1) ; 2; ((<3; 4); 5) ; ((<a:)) ; ((<(<6))) ; 7; 8; <a:

+---+-+-----------+----+-----+-+-+--+

 

flatten li

 

'''Notes:'''

'''Alternative Solution:'''<br>

The previous solution can be generalized to flatten the nesting and shape for a list of arbitrary values that include arrays of any rank:

 

'''Example:'''

+---+-+---------------------+----+------+--+--+--+

|+-+|2|+-------+-----------+|+--+|+----+|18|19|++|

1 2 3 4 5 6 7 8

flatten2 li2

 

Here, we have replaced <code><S:0</code> with <code><@,S:0</code> so our leaves are flattened before the final step where their boxes are razed.

 

Actual Workhorse code

import java.util.List;

 

}

}

 

Method showing population of the test List and usage of flatten method.

import java.util.List;

 

return asList(a);

}

 

{{out}}

;Functional version

{{works with|Java|8+}}

import java.util.stream.Stream;

import java.util.stream.Collectors;

return flattenToStream(list).collect(Collectors.toList());

}

 

=={{header|JavaScript}}==

===ES5===

return list.reduce(function (acc, val) {

return acc.concat(val.constructor === Array ? flatten(val) : val);

}, []);

 

 

Or, expressed in terms of the more generic '''concatMap''' function:

 

'use strict';

 

);

 

 

 

From fusion of ''flatten'' with ''concatMap'' we can then derive:

 

function flatten(a) {

return a instanceof Array ? [].concat.apply([], a.map(flatten)) : a;

 

For example:

 

'use strict';

 

);

 

 

{{Out}}

 

====Built-in====

 

====Recursive====

const flatten = t => {

const go = x =>

) : x;

return go(t);

 

====Iterative====

for (let i = 0; i < list.length; i++) {

while (true) {

}

return list;

 

Or alternatively:

 

const flatten = t => {

let xs = t;

return xs;

 

Result is always:

 

=={{header|Joy}}==

"seqlib" libload.

 

 

(* output: [1 2 3 4 5 6 7 8] *)

 

=={{header|jq}}==

reduce .[] as $i

([];

if $i | type == "array" then . + ($i | flatten)

else . + [$i]

[[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []] | flatten

 

=={{header|Jsish}}==

From Javascript entry, with change to test for ''typeof'' equal ''"array"''.

 

function flatten(list) {

return list.reduce(function (acc, val) {

flatten([[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]) ==> [ 1, 2, 3, 4, 5, 6, 7, 8 ]

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

 

An iterative recursive version that uses less memory but is slower:

end

grep(arr)

 

arr = [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]

 

 

<pre>

</pre>

 

 

So to flatten a list of arbitrary depth, you can join-over-over, or reduce a list with a function that reduces a list with a join function:

 

=={{header|Kotlin}}==

 

@Suppress("UNCHECKED_CAST")

flattenList(nestList, flatList)

println("Flattened : " + flatList)

 

Or, using a more functional approach:

 

fun flatten(list: List<*>): List<*> {

fun flattenElement(elem: Any?): Iterable<*> {

}

return list.flatMap { elem -> flattenElement(elem) }

 

{{out}}

=={{header|Lambdatalk}}==

Lambdatalk doesn't have a builtin primitive flattening a multidimensionnal array.

1) Let's create this function

 

{A.flatten {list}}

-> [1,2,3,4,5,6,7,8]

 

=={{header|Lasso}}==

Lasso Delve is a Lasso utility method explicitly for handling embedded arrays. With one array which contain other arrays, delve allows you to treat one array as a single series of elements, thus enabling easy access to an entire tree of values. [http://www.lassosoft.com/lassoDocs/languageReference/obj/delve www.lassosoft.com/lassoDocs/languageReference/obj/delve Lasso reference on Delve]

 

 

#original

'<br />'

(with item in delve(#original)

<pre>array(array(1), 2, array(array(3, 4), 5), array(array(array())), array(array(array(6))), 7, 8, array())

staticarray(1, 2, 3, 4, 5, 6, 7, 8)</pre>

 

=={{header|LFE}}==

> (: lists flatten '((1) 2 ((3 4) 5) ((())) (((6))) 7 8 ()))

(1 2 3 4 5 6 7 8)

 

=={{header|Logo}}==

if not list? :l [output :l]

if empty? :l [output []]

 

make "a [[1] 2 [[3 4] 5] [[[]]] [[[6]]] 7 8 []]

 

=={{header|Logtalk}}==

flatten(List, [], Flatted).

 

flatten(Tail, List, Aux),

flatten(Head, Aux, Flatted).

 

=={{header|Lua}}==

 

if type(list) ~= "table" then return {list} end

local flat_list = {}

test_list = {{1}, 2, {{3,4}, 5}, {{{}}}, {{{6}}}, 7, 8, {}}

 

 

=={{header|Maple}}==

This can be accomplished using the <code>Flatten</code> command from the <code>ListTools</code>, or with a custom recursive procedure.

 

L := [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]:

 

 

Flatten(L);

{{out}}

<pre>

</pre>

 

flatten := proc(x)

`if`(type(x,'list'),seq(procname(i),i = x),x);

 

[flatten(L)];

{{out}}

<pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|Maxima}}==

 

=={{header|Mercury}}==

As with Haskell we need to use an algebraic data type.

:- interface.

 

 

:- end_module flatten_a_list.

{{out}}

<pre>

 

=={{header|min}}==

 

{{out}}

 

=={{header|Mirah}}==

import java.util.List

import java.util.Collection

source = [[1], 2, [[3, 4], 5], [[ArrayList.new]], [[[6]]], 7, 8, ArrayList.new]

 

 

=={{header|NewLISP}}==

(1 2 3 4 5 6 7 8)

 

=={{header|NGS}}==

NGS defines '''flatten''' as a shallow flatten, hence using '''flatten_r''' here.

 

collector {

local kern

}

 

 

{{out}}

 

=={{header|Nim}}==

case isLeaf: bool

of false: list: seq[TreeList[T]]

 

proc L[T](list: varargs[TreeList[T]]): TreeList[T] =

 

proc N[T](data: T): TreeList[T] =

TreeList[T](isLeaf: true, data: data)

 

proc flatten[T](n: TreeList[T]): seq[T] =

if n.isLeaf: result = @[n.data]

else:

for x in n.list:

result.add flatten x

 

var x = L(L(N 1), N 2, L(L(N 3, N 4), N 5), L(L(L[int]())), L(L(L(N 6))), N 7, N 8, L[int]())

{{out}}

 

=={{header|Objective-C}}==

{{works with|Cocoa}}

 

@interface NSArray (FlattenExt)

return 0;

 

=={{header|OCaml}}==

val flatten : 'a list list -> 'a list = <fun>

 

# (* use another data which can be accepted by the type system *)

flatten [[1]; [2; 3; 4]; []; [5; 6]; [7]; [8]] ;;

 

Since OCaml is statically typed, it is not possible to have a value that could be both a list and a non-list. Instead, we can use an algebraic datatype:

 

type 'a tree = Leaf of 'a | Node of 'a tree list

 

 

# flatten (Node [Node [Leaf 1]; Leaf 2; Node [Node [Leaf 3; Leaf 4]; Leaf 5]; Node [Node [Node []]]; Node [Node [Node [Leaf 6]]]; Leaf 7; Leaf 8; Node []]) ;;

 

=={{header|Oforth}}==

 

 

{{out}}

 

=={{header|Ol}}==

(define (flatten x)

(cond

(print

(flatten '((1) 2 ((3 4) 5) ((())) (((6))) 7 8 ())))

{{Out}}

<pre>

 

=={{header|ooRexx}}==

sub1 = .array~of(1)

sub2 = .array~of(3, 4)

else accumulator~append(item)

end

 

=={{header|Oz}}==

Oz has a standard library function "Flatten":

A simple, non-optimized implementation could look like this:

case Xs of nil then nil

[] X|Xr then

end

end

 

=={{header|PARI/GP}}==

my(u=[]);

for(i=1,#v,

);

u

 

=={{header|Perl}}==

map { ref eq 'ARRAY' ? flatten(@$_) : $_ } @_

}

 

my @lst = ([1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []);

 

=={{header|Phix}}==

standard builtin

{{out}}

<pre>

 

=={{header|Phixmonti}}==

{{out}}

<pre>

=={{header|PHP}}==

{{works with|PHP|4.x only, not 5.x}}

It won't work on PHP 5 due to the change in behavior of array_merge(). */

while (array_filter($lst, 'is_array'))

Explanation: while <code>$lst</code> has any elements which are themselves arrays (i.e. <code>$lst</code> is not flat), we merge the elements all together (in PHP 4, <code>array_merge()</code> treated non-array arguments as if they were 1-element arrays; PHP 5 <code>array_merge()</code> no longer allows non-array arguments.), thus flattening the top level of any embedded arrays. Repeat this process until the array is flat.

 

===Recursive===

 

function flatten($ary) {

$result = array();

$lst = array(array(1), 2, array(array(3, 4), 5), array(array(array())), array(array(array(6))), 7, 8, array());

var_dump(flatten($lst));

 

Alternatively:{{works with|PHP|5.3+}}

 

function flatten($ary) {

$result = array();

$lst = array(array(1), 2, array(array(3, 4), 5), array(array(array())), array(array(array(6))), 7, 8, array());

var_dump(flatten($lst));

 

function flatten_helper($x, $k, $obj) {

$obj->flattened[] = $x;

$lst = array(array(1), 2, array(array(3, 4), 5), array(array(array())), array(array(array(6))), 7, 8, array());

var_dump(flatten($lst));

 

Using the standard library (warning: objects will also be flattened by this method):

 

$lst = array(array(1), 2, array(array(3, 4), 5), array(array(array())), array(array(array(6))), 7, 8, array());

$result = iterator_to_array(new RecursiveIteratorIterator(new RecursiveArrayIterator($lst)), false);

var_dump($result);

 

===Non-recursive===

 

Function flat is iterative and flattens the array in-place.

function flat(&$ary) { // argument must be by reference or array will just be copied

for ($i = 0; $i < count($ary); $i++) {

flat($lst);

var_dump($lst);

 

=={{header|PicoLisp}}==

(make # Build a list

(recur (X) # recursively over 'X'

(if (atom X)

(link X) # Put atoms into the result

 

or a more succint way using [http://www.software-lab.de/doc/refF.html#fish fish]:

 

 

=={{header|Pike}}==

There's a built-in function called <code>Array.flatten()</code> which does this, but here's a custom function:

array r = ({ });

return r;

 

=={{header|PL/I}}==

The Translate(text,that,this) intrinsic function returns ''text'' with any character in ''text'' that is found in ''this'' (say the third) replaced by the corresponding third character in ''that''. Suppose the availability of a function Replace(text,that,this) which returns ''text'' with all occurrences of ''this'' (a single text, possibly many characters) replaced by ''that'', possibly zero characters. The Translate function does not change the length of its string, simply translate its characters in place.

list = translate (list, ' ', '[]' ); /*Produces " 1 , 2, 3,4 , 5 , , 6 , 7, 8, " */

list = Replace(list,'',' '); /*Converts spaces to nothing. Same parameter order as Translate.*/

end; /*And search afresh, in case of multiple commas in a row.*/

list = '[' || list || ']'; /*Repackage the list.*/

This is distinctly crude. A user-written Replace function is confronted by the requirement to specify a maximum size for its returned result, for instance <code>Replace:Procedure(text,that,this) Returns(Character 200 Varying);</code> which is troublesome for general use. The intrinsic function Translate has no such restriction.

 

=={{header|PostScript}}==

{{libheader|initlib}}

/flatten {

/.f {{type /arraytype eq} {{.f} map aload pop} ift}.

[exch .f]

}.

[[1] 2 [[3 4] 5] [[[]]] [[[6]]] 7 8 []] flatten

 

=={{header|PowerShell}}==

function flatten($a) {

if($a.Count -gt 1) {

$a = @(@(1), 2, @(@(3,4), 5), @(@(@())), @(@(@(6))), 7, 8, @())

"$(flatten $a)"

<b>Output:</b>

<pre>

 

=={{header|Prolog}}==

flatten(List, FlatList) :-

flatten(List, [], FlatList).

 

flatten(NonList, T, [NonList|T]).

 

=={{header|Python}}==

===Recursive===

return sum( ([x] if not isinstance(x, list) else flatten(x)

for x in lst), [] )

>>> lst = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

>>> flatten(lst)

 

 

>>> lst = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

 

 

Function flat is iterative and flattens the list in-place. It follows the Python idiom of returning None when acting in-place:

i=0

while i<len(lst):

>>> flat(lst)

>>> lst

 

===Generative===

In this case, the generator is converted back to a list before printing.

 

for x in lst:

if isinstance(x, list):

>>> lst = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

>>> print list(flatten(lst))

 

===Functional Recursive===

 

{{Works with|Python|3.7}}

 

from itertools import (chain)

 

if __name__ == '__main__':

{{Out}}

<pre>Flatten a nested list:

 

{{Works with|Python|3.7}}

 

from functools import (reduce)

 

if __name__ == '__main__':

{{Out}}

<pre>From nested list to flattened list:

{{trans|K}}

We repeatedly apply <tt>raze</tt> until the return value converges to a fixed value.

 

=={{header|Quackery}}==

 

[ [] swap

[ dup nest?

if flatten

 

'''Output:'''

...

 

 

=={{header|R}}==

 

 

=={{header|Racket}}==

Racket has a built-in flatten function:

#lang racket

(flatten '(1 (2 (3 4 5) (6 7)) 8 9))

{{out}}

<pre>

 

or, writing it explicitly with the same result:

#lang racket

(define (flatten l)

[else (append (flatten (first l)) (flatten (rest l)))]))

(flatten '(1 (2 (3 4 5) (6 7)) 8 9))

 

=={{header|Raku}}==

{{works with|Rakudo Star|2018.03}}

 

 

say .perl given gather @l.deepmap(*.take); # lazy recursive version

# Another way to do it is with a recursive function (here actually a Block calling itself with the &?BLOCK dynamic variable):

 

 

=={{header|REBOL}}==

flatten: func [

"Flatten the block in place."

head block

]

 

Sample: <pre>

 

=={{header|Red}}==

flatten: function [

"Flatten the block"

>> blk: [1 2 ["test"] "a" [["bb"]] 3 4 [[[99]]]]

>> form blk

 

=={{header|REXX}}==

{{trans|PL/I}}

list= '[[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]' /*the list to be flattened. */

say list /*display the original list. */

list= strip(list, 'T', c) /*strip the last trailing comma*/

list = '['list"]" /*repackage the list. */

{{out|output|:}}

<pre>

 

=={{header|Ring}}==

aString = "[[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]"

bString = ""

cString = '"' + cString + '"'

see cString + nl

<pre>

"1, 2, 3, 4, 5, 6, 7, 8"

</pre>

 

=={{header|Ruby}}==

<code>flatten</code> is a built-in method of Arrays

The <code>flatten</code> method takes an optional argument, which dedicates the amount of levels to be flattened.

# => [1, 2, [3, 4], 5, [[]], [[6]], 7, 8]

 

=={{header|Rust}}==

First we have to create a type that supports arbitrary nesting:

 

enum List<T> {

println!();

 

{{output}}

<pre>1 2 3 4 5 6 7 8

 

=={{header|S-lang}}==

 

define flatten (list) {

}

return retval;

 

Sample:

 

=={{header|Scala}}==

case Nil => Nil

case (head: List[_]) :: tail => flatList(head) ::: flatList(tail)

case head :: tail => head :: flatList(tail)

 

Sample:

 

=={{header|Scheme}}==

(cond ((null? x) '())

((not (pair? x)) (list x))

 

> (flatten '((1) 2 ((3 4) 5) ((())) (((6))) 7 8 ()))

 

=={{header|Shen}}==

(define flatten

[] -> []

 

(flatten [[1] 2 [[3 4] 5] [[[]]] [[[6]]] 7 8 []])

{{out}}

<pre>

 

=={{header|Sidef}}==

var flat = []

a.each { |item|

var arr = [[1], 2, [[3,4], 5], [[[]]], [[[6]]], 7, 8, []]

say flatten(arr) # used-defined function

 

=={{header|Slate}}==

[

[| :out | s flattenOn: out] writingAs: s

ifTrue: [value flattenOn: w]

ifFalse: [w nextPut: value]].

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

 

flatten [ |f|

f := OrderedCollection new.

{{{}}} . {{{6}}} . 7 . 8 . {} }.

 

 

Here is a non-OOP (but functional) version, which uses a block-closure as function (showing higher order features of Smalltalk):

 

flatDo :=

[:element :action |

flatDo

value:collection

 

of course, many Smalltalk libraries already provide such functionality.

{{works with|Smalltalk/X}} {{works with|Pharo}}

 

=={{header|Standard ML}}==

In Standard ML, list must be homogeneous, but nested lists can be implemented as a tree-like data structure using a <code>datatype</code> statement:

L of 'a (* leaf *)

| N of 'a nestedList list (* node *)

Flattening of this structure is similar to flatten trees:

 

{{out}}

 

=={{header|Suneido}}==

 

{{out}}

=={{header|SuperCollider}}==

SuperCollider has the method "flat", which completely flattens nested lists, and the method "flatten(n)" to flatten a certain number of levels.

a = [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []];

a.flatten(1); // answers [ 1, 2, [ 3, 4 ], 5, [ [ ] ], [ [ 6 ] ], 7, 8 ]

a.flat; // answers [ 1, 2, 3, 4, 5, 6, 7, 8 ]

 

Written as a function:

(

f = { |x|

};

f.([[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]);

 

=={{header|Swift}}==

return s

}

println(s)

let result : [Int] = flatten(s)

{{out}}

<pre>

More functionally:

{{works with|Swift|1.2+}}

return s

}

println(s)

let result : [Int] = flatten(s)

{{out}}

<pre>

</pre>

 

{{works with|Swift|2.0+}}

{

return s

let result: [Int] = flatten(input)

 

{{out}}

<pre>

 

=={{header|Tailspin}}==

templates flatten

[ $ -> # ] !

 

[[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []] -> flatten -> !OUT::write

{{out}}

<pre>

 

=={{header|Tcl}}==

for {set old {}} {$old ne $list} {} {

set old $list

 

puts [flatten {{1} 2 {{3 4} 5} {{{}}} {{{6}}} 7 8 {}}]

Note that because lists are not syntactically distinct from strings, it is probably a mistake to use this procedure with real (especially non-numeric) data. Also note that there are no parentheses around the outside of the list when printed; this is just a feature of how Tcl regards lists, and the value is a proper list (it can be indexed into with <code>lindex</code>, iterated over with <code>foreach</code>, etc.)

 

Another implementation that's slightly more terse:

 

while { $data != [set data [join $data]] } { }

return $data

}

puts [flatten {{1} 2 {{3 4} 5} {{{}}} {{{6}}} 7 8 {}}]

 

=={{header|Trith}}==

 

{{omit from|UNIX Shell}}

 

=={{header|TXR}}==

An important builtin.

@(bind bar foo)

 

Run:

 

=====Implementation=====

class flattener

dim separator

end property

end class

 

=====Invocation=====

dim flat

set flat = new flattener

flat.itemSeparator = "~"

wscript.echo join( flat.flatten( array( array( 1 ),2,array(array(3,4),5),array(array(array())),array(array(array(6))),7,8,array())), "!")

 

{{out}}

=====Alternative (classless) Version=====

{{works with|Windows Script Host|*}}

' Flatten the example array...

a = FlattenArray(Array(Array(1), 2, Array(Array(3,4), 5), Array(Array(Array())), Array(Array(Array(6))), 7, 8, Array()))

Next

End Sub

 

=={{header|Wart}}==

Here's how Wart implements <code>flatten</code>:

if no.seq

acc

(cons seq acc)

:else

 

{{out}}

 

=={{header|WDTE}}==

let s => import 'stream';

 

})

-> s.collect

 

'''Usage:'''

 

{{out}}

{{libheader|Wren-seq}}

A method already exists for this operation in the above module.

 

var a = [[1], 2, [[3, 4], 5], [[[]]], [[[6]]], 7, 8, []]

 

{{out}}

[1, 2, 3, 4, 5, 6, 7, 8]

</pre>

 

=={{header|zkl}}==

fcn(i){ if(List.isType(i)) return(Void.Recurse,i,self.fcn); i}) }

 

flatten(L(L(1), L(2), L(L(3,4), 5), L(L(L())), L(L(L(6))), 7, 8, L()))

This works by recursively writing the contents of lists to a new list. If a list is recursive or cyclic, it will blow the stack and throw an exception.