#include <stddef.h>
#include "serene/rt/core.h"

Include dependency graph for lists.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	srn_list_node_t
	A list is a singly linked sequence of values. More...

struct	srn_list_t
	Since all the values are immutable and persistent. More...

Typedefs
typedef struct srn_list_node_t	srn_list_node_t
	A list is a singly linked sequence of values.

typedef struct srn_list_t	srn_list_t

Functions
srn_value_t *	srn_list_make (srn_context_t ctx, srn_metadata_t metadata, srn_value_t const items, size_t count)
	Build a list from an array of elements.

srn_value_t *	srn_list_cons (srn_context_t ctx, srn_metadata_t metadata, srn_value_t value, srn_value_t list)
	Prepend `value` to `list`, returning a new list.

Typedef Documentation

◆ srn_list_node_t

typedef struct srn_list_node_t srn_list_node_t

A list is a singly linked sequence of values.

Nodes hold a value and a pointer to the next node; the list header caches the length and points at the head node. Empty lists are represented by nil_v; a list value with tag VList always has at least one element.

◆ srn_list_t

typedef struct srn_list_t srn_list_t

Function Documentation

◆ srn_list_cons()

srn_value_t * srn_list_cons	(	srn_context_t *	ctx,
		srn_metadata_t *	metadata,
		srn_value_t *	value,
		srn_value_t *	list )

Prepend value to list, returning a new list.

list may be nil_v (treated as the empty list); the input list is not modified — its nodes are shared with the returned list.

Definition at line 48 of file lists.c.

                                              {
  PANIC_IF_NULL(ctx);
  PANIC_IF_NULL(value);
  PANIC_IF_NULL(list);
 
  srn_list_node_t *next_head = nullptr;
  size_t next_len = 0;
  if (!IS_NIL(list)) {
    srn_list_t *l = AS_LIST(list);
    next_head = l->head;
    next_len = l->len;
  }
 
  srn_list_node_t *node = ALLOC(ctx, srn_list_node_t);
  node->value = value;
  node->next = next_head;
 
  srn_list_t *result = ALLOC(ctx, srn_list_t);
  result->len = next_len + 1;
  result->head = node;
  return srn_value_make(ctx, VList, metadata, (void *)result);
}

Here is the call graph for this function:

◆ srn_list_make()

srn_value_t * srn_list_make	(	srn_context_t *	ctx,
		srn_metadata_t *	metadata,
		srn_value_t const	items,
		size_t	count )

Build a list from an array of elements.

When count == 0, returns nil_v (empty lists have no allocated representation). Otherwise allocates one node per element plus the list header, all in ctx.

Definition at line 24 of file lists.c.

                                         {
  PANIC_IF_NULL(ctx);
  if (count == 0) {
    return &nil_v;
  }
  PANIC_IF_NULL(items);
 
  // Build the chain from the tail back to the head so each node's `next`
  // already points at an initialized successor.
  srn_list_node_t *head = nullptr;
  for (size_t i = count; i-- > 0;) {
    srn_list_node_t *node = ALLOC(ctx, srn_list_node_t);
    node->value = items[i];
    node->next = head;
    head = node;
  }
 
  srn_list_t *list = ALLOC(ctx, srn_list_t);
  list->len = count;
  list->head = head;
  return srn_value_make(ctx, VList, metadata, (void *)list);
}