• Perl

my $tree = {
           'Root' => {
                 'Child1' => {
                       'GrandChild1' => {},
                       'GrandChild2' => {}
                 },
                 'Child2' => {}
           }
};

• C

typedef struct node_s
{
    int value;
    struct node_s *nextSibling;
    struct node_s *firstChild;
} node_t;

• Caml

type 'a Tree = {
	value: 'a;
	children: 'a tree list;
}

• C++

template<typename T>
struct Node{
  T value;
  std::vector<Node<T>> children;
};

• C#

class Node<T>
{
 T value;
 List<Node<T>> childNodes;
}

• D

struct Node(T){
    Node[] children;
    T data;
}

alias TreeOfIntegers = Node!(int);

• Dart

class Node<T> {
  final T value;
  final List<Node<T>> children;
  Node(this.value, this.children);
}
  

• Erlang

-record( node,{
	value         :: any(),
	children = [] :: [node#{}]
}).

• Fortran

type node_t
  integer:: value
  type(node_t), pointer :: next_sibling;
  type(node_t), pointer :: first_child;
end type node_t

• Go

type Tree[L any] struct {
	Label    L
	Children []*Tree[L]
}

• Go

type Tree struct {
	Key keyType
	Deco valueType
	Children []*Tree
}

• Haskell

data Tree a = Node {
    value :: a,
    children :: [Tree a]
}

• JS

class Node {
  constructor (value, children = []) {
    this.value = value
    this.children = children
  }
}

• Java

class Tree<K,V> {
  K key;
  V deco;
  List<Tree<K,V>> children = new ArrayList<>();
}

• Lua

local function Tree(v, c)
	return {
		val = v,
		children = c
	}
end

• Obj-C

@interface Node:NSObject
@property id value; // id means any object value
@property NSMutableArray *children;
@end

// usage like
Node *n=[Node new];
n.value=@1;
[n.children addObject:otherNode];
[n.children removeLastObject];

// somewhere needed also
@implementation Node
-(instancetype)init {
  if (!(self=[super init])) return nil;
  _children=[NSMutableArray array];
  return self;
}
@end

• PHP

final class Node {
    public function __construct(public array $children, public mixed $data) {}
}

• PHP

class Tree
{
    public $children = [];
    public $data;
    
    public function __construct($data, $children)
    {
        $this->data = $data;
        $this->children = $children;
    }
}

• Pascal

type
  TTree = class
    Children: array of TTree;
    Data: TObject;
  end;     

• Pascal

type
generic
  TTree<_T> = class(TObject)
    Children: array of TObject;
    Data: _T;
  end;

type
  TStringTree = specialize TTree<String>;

• Python

class Node:
    def __init__(self, value, *children):
        self.value = value
        self.children = list(children)

• Ruby

Node = Struct.new(:children)
parent = Node.new([])
parent.children << Node.new([])

• Rust

struct Node<T> {
  value: T,
  children: Vec<Node<T>>,
}

• Scala

case class Node[T](value: T, children: List[Node[T]] = Nil)

• Scheme

(define (make-tree value children)
  (cons value children))

(define (tree-value t) (car t))
(define (tree-first-child t) (cadr t))
(define (tree-rest-children t) (cddr t))