# Miscellaneous

# Buffered channels.

# make-channel

(make-channel ...)

Please document me!

# channel?

(channel? ...)

Please document me!

# channel-put

(channel-put ...)

Please document me!

# channel-try-put

(channel-try-put ...)

Please document me!

# channel-sync

(channel-sync ...)

Please document me!

# channel-get

(channel-get ...)

Please document me!

# channel-try-get

(channel-try-get ...)

Please document me!

# channel-close

(channel-close ...)

Please document me!

# channel-closed?

(channel-closed? ...)

Please document me!

# Asynchronous Completions

# completion

(defsyntax completion ...)

Completion type for user-defined generics.

# make-completion

(make-completion)
=> <completion>

Creates a new asynchronous completion.

# completion?

(completion? obj)
=> boolean

Returns true if the object is a completion.

# completion-ready?

(completion-ready? c)
=> boolean

Returns true if the completion is ready.

# completion-wait!

(completion-wait! c)
  c := competion
=> any

Waits on the completion until it has been posted with completion-post! or an error has been signaled with completion-error!. If the completion was posted, the posted value is returned. If an error was signalled, then it is raised as an exception.

# completion-post!

(completion-post! c val)
  c := completion

Posts the completion with value val.

# completion-error!

(completion-error! c exn)
  exn := completion

Signals an error in the completion.

# with-completion-error

(with-completion-error c body ...)
  c := completion

Evaluates body ... with an exception handler that signals an error in the completion.

# Thread Barriers

# barrier

(defsyntax barrier ...)

Barrier type for user-defined generics.

# make-barrier

(make-barrier limit)
  limit := fixnum
=> <barrier>

Create a barrier, awaiting for limit threads.

# barrier?

(barrier? obj)
=> boolean

Returns true if the object is a barrier.

# barrier-wait!

(barrier-wait! b)
  b := barrier

Waits on a thread barrier until it has been posted limit times with barrier-post! or an error has been signaled with barrier-error!.

# barrier-post!

(barrier-post! b)
  b := barrier

Posts the barrier.

# barrier-error!

(barrier-error! b exn)

Signals an error on the barrier.

# with-barrier-error

(with-barrier-error b body ...)
  b := barrier

Evaluates body ... with an exception handler that signals an error in the barrier.

# Deques

# deque

(defsyntax deque ...)

Deque type for user-defined generics.

# make-deque

(make-deque)
=> <deque>

Creates a new deque.

# deque?

(deque? obj)
=> boolean

Returns true if the object is a deque.

# deque-length

(deque-length dq)
  dq := deque
=> integer

Returns the size of the deque.

# deque-empty?

(deque-empty? dq)
  dq := deque
=> boolean

Returns true if the deque is empty.

# push-front!

(push-front! dq v)
  dq := deque

Enqueues (pushes) the value v to the front of the queue.

# pop-front!

(pop-front! dq [default])
  dq := deque
=> any

Pops the front of the queue and a returns the value. If the deque is empty and a default value is supplied, then it is returned. Otherwise an error is raised.

# peek-front

(peek-front dq [default])
  dq := deque
=> any

Peeks the front of the queue and a returns the value without popping it If the deque is empty and a default value is supplied, then it is returned. Otherwise an error is raised.

# push-back!

(push-back! dq v)

Enqueues (pushes) the value v to the back of the queue.

# pop-back!

(pop-back! dq [default])
  dq := deque
=> any

Pops the back of the queue and a returns the value. If the deque is empty and a default value is supplied, then it is returned. Otherwise an error is raised.

# peek-back

(peek-back dq [default])
  dq := deque
=> any

Peeks the back of the queue and a returns the value without popping it If the deque is empty and a default value is supplied, then it is returned. Otherwise an error is raised.

# deque->list

(deque->list dq)
  dq := deque
=> list

Returns a list of the value contained in the deque, in order.

# List utilities

# alist?

(alist? ...)

Please document me!

# plist?

(plist? ...)

Please document me!

# plist->alist

(plist->alist ...)

Please document me!

# alist->plist

(alist->plist ...)

Please document me!

# length=?

(length=? ...)

Please document me!

# length=n?

(length=n? ...)

Please document me!

# length<?

(length<? ...)

Please document me!

# length<n?

(length<n? ...)

Please document me!

# length<=?

(length<=? ...)

Please document me!

# length<=n?

(length<=n? ...)

Please document me!

# length>?

(length>? ...)

Please document me!

# length>n?

(length>n? ...)

Please document me!

# length>=?

(length>=? ...)

Please document me!

# length>=n?

(length>=n? ...)

Please document me!

# call-with-list-builder

(call-with-list-builder ...)

Please document me!

# with-list-builder

(with-list-builder ...)

Please document me!

# snoc

(snoc ...)

Please document me!

# append1

(append1 ...)

Please document me!

# for-each!

(for-each! ...)

Please document me!

# push!

(push! ...)

Please document me!

# flatten1

> (flatten1 [1 [2]])
=> (1 2)

> (flatten1 [1 [2] [[3]]])
=> (1 2 (3))

Removes one layer of a nested proper list.

# flatten

> (flatten [1 [2]])
=> (1 2)

> (flatten [1 [2] [[3]]])
=> (1 2 3)

Removes all nested layers of a proper list.

# when-list-or-empty

(when-list-or-empty list body ...)

# lru-cache

(defsyntax lru-cache ...)

LRU cache type for user-defined generics.

# make-lru-cache

(make-lru-cache cap)
  cap := fixnum; LRU cache capacity
=> <lru-cache>

Creates a new LRU cache with capacity cap, which must be > 1.

# lru-cache?

(lru-cache? obj)
=> boolean

Returns true if the object is an LRU cache.

# lru-cache-ref

(lru-cache-ref lru key [default])
  lru := lru-cache

Returns the association of key in the LRU cache, and promotes the node to the head of the LRU queue. If there is no association, then default is returned. If the default is omitted, then an error is raised.

# lru-cache-get

(lru-cache-get lru key)
  lru := lru-cache

Same as (lru-cache-ref lru key #f).

# lru-cache-put!

(lru-cache-put! lru key val)
  lru := lru-cache

Puts an association of key to val into the LRU cache. If the cache is full, then the tail of the LRU queue (ie the value least recently used) is dropped from the cache.

# lru-cache-remove!

(lru-cache-remove! lru key)
  lru := lru-cache

Removes the association of key from the LRU cache.

# lru-cache-size

(lru-cache-size lru)
  lru := lru-cache
=> fixnum

Returns the current size of the LRU cache.

# lru-cache-capacity

(lru-cache-capacity lru)
  lru := lru-cache
=> fixnum

Returns the capacity of the LRU cache.

# lru-cache-flush!

(lru-cache-flush! lru)
  lru := lru-cache

Clears the LRU cache.

# lru-cache-for-each

(lru-cache-for-each proc lru)
  proc := lambda (key value)
  lru  := lru-cache

Applies (proc key val) for every key-value association in the LRU cache, in most recently used order.

# lru-cache-walk

(lru-cache-walk lru proc)

Same as (lru-cache-for-each proc lru).

# lru-cache-fold

(lru-cache-fold proc iv lru)
  proc := lambda (key value r)
  lru  := lru-cache

Folds the LRU cache in Most Recently Used order.

# lru-cache-foldr

(lru-cache-foldr proc iv lru)
  proc := lambda (key value r)
  lru  := lru-cache

Folds the LRU cache in Least Recently Used order.

# lru-cache->list

(lru-cache->list lru)
=> alist

Returns an alist of key-value associations in the cache.

# in-lru-cache

(in-lru-cache lru)
  lru := lru-cache
=> iterator

Creates an iterator over the LRU cache.

# in-lru-cache-keys

(in-lru-cache-keys lru)
  lru := lru-cache
=> iterator

Creates an iterator over the LRU cache keys.

# in-lru-cache-values

(in-lru-cache-values lru)
  lru := lru-cache
=> iterator

Creates an iterator over the LRU cache values.

# Port utilities

# copy-port

(copy-port ...)

Please document me!

# read-all-as-string

(read-all-as-string ...)

Please document me!

# read-file-string

(read-file-string ...)

Please document me!

# read-all-as-lines

(read-all-as-lines ...)

Please document me!

# read-file-lines

(read-file-lines ...)

Please document me!

# Port Destructor

(defmethod {destroy <port>} close-port)

The module also defines a destroy method for ports, so that they can be used in with-destroy forms and other primitives that use the destroy idiom.

# Priority Queues

# pqueue

(defsyntax pqueue ...)

Priority queue type, for user-defined generics.

# make-pqueue

(make-pqueue prio [cmp = <])
  prio := lambda (any) => any; element priority function
  cmp  := priority comparison function
=> pqueue

Creates a new priority queue.

# pqueue?

(pqueue? obj)
=> boolean

Returns true if the object is a priority queue.

# pqueue-empty?

(pqueue-empty? pq)
  pq := pqueue
=> boolean

Returns true if the priority queue is empty.

# pqueue-size

(pqueue-size pq)
  pq := pqueue
=> integer

Returns the size of the priority queue.

# pqueue-peek

(pqueue-peek pq [default])
  pq := pqueue
=> any

Peeks the next value in the queue, without popping it. If the queue is empty and a default value is supplied, then it is returned. Otherwise an error is raised.

# pqueue-pop!

(pqueue-pop! pq [default])
  pq := pqueue
=> any

Peeks the next value in the queue, and returns it. If the queue is empty and a default value is supplied, then it is returned. Otherwise an error is raised.

# pqueue-push!

(pqueue-push! pq v)
  pq := pqueue

Pushes the value v in the queue.

# Proces Utilities

# Overview

These utilities synchronously spawn a subprocess, spawn a coprocess function in a thread to interact with the process (default: std/misc/ports#read-all-as-string), check the status of the process upon termination, and return the result of that coprocess if successful.

# run-process

(run-process ...)

Please document me!

# run-process/batch

(run-process/batch ...)

Please document me!

# Simple Queues

# queue

(defsyntax queue ...)

Queue type, for user-defined generics.

# make-queue

(make-queue)
=> <queue>

Creates a new queue.

# queue?

(queue? obj)
=> boolean

Returns true if the object is a queue.

# queue-length

(queue-length q)
  q := queue
=> integer

Returns the size of the queue.

# queue-empty?

(queue-empty? q)
  q := queue
=> boolean

Returns true if the queue is empty.

# non-empty-queue?

(non-empty-queue? q)

Returns true if the queue is not empty.

# enqueue!

(enqueue! q v)
  q := queue

Enqueues (pushes) the value v to the end of the queue.

# enqueue-front!

(enqueue-front! q v)
  q := queue

Enqueues the value v at the front of the queue.

# dequeue!

(dequeue! q [default])
  q := queue
=> any

Pops the end of the queue and a returns the value. If the queue is empty and a default value is supplied, then it is returned. Otherwise an error is raised.

# queue-peek

(queue-peek q [default])
  q := queue
=> any

Peeks the end of the queue and a returns the value without popping it from the queue. If the queue is empty and a default value is supplied, then it is returned. Otherwise an error is raised.

# queue->list

(queue->list q)
=> list

Returns a list of the value contained in the queue, in order.

# Red Black Trees

# rbtree

(defsyntax rbtree)

Red Black tree (rbtree) type.

# rbtree?

(rbtree? obj)
=> boolean

Returns true if the object is an rbtree.

# make-rbtree

(make-rbtree cmp)
  cmp := lambda (a b); comparison procedure
=> <rbtree>

Creates a new rbtree.

The comparison procedure accepts two keys, a and b, and performs ternary comparison:

• if a < b, then it must return a negative number
• if a = b, then it must return 0
• if a > b, then it must returna positive number

# rbtree-ref

(rbtree-ref rbt key [default])
  rbt := rbtree
=> any

Returns the value associated with key in the rbtree, or the default if no association is present; if the default value is omitted then an error is raised.

# rbtree-get

(rbtree-get rbt key)
  rbt := rbtree
=> any

Same as (rbtree-ref rbt key #f).

# rbtree-put!

(rbtree-put! rbt key value)
 rbt := rbtree

Destructively updates the rbtree, associating key with value.

# rbtree-put

(rbtree-put rbt key value)
  rbt := rbtree
=> rbtree

Functionally updates the rbtree, associating key with value.

# rbtree-update!

(rbtree-update! rbt k update default)
  rbt := rbtree
  update := lambda (x y); update function

Destructively updates the rbtree.

# rbtree-update

(rbtree-update rbt k update default)
=> rbtree

Functionally updates the rbtree.

# rbtree-remove!

(rbtree-remove! rbt key)
  rbt := rbtree

Destructively updates the rbtree, removing the association of key.

# rbtree-remove

(rbtree-remove rbt key)
  rbt := rbtree
=> rbtree

Functionally updates the rbtree, removing the association of key.

# rbtree-empty?

(rbtree-empty? rbt)
  rbt := rbtree
=> boolean

Returns true if the rbtree is an empty.

# rbtree-copy

(rbtree-copy rbt)
  rbt := rbtree
=> rbtree

Returns a copy of the rbtree.

# rbtree-for-each

(rbtree-for-each proc rbt)
  proc := lambda (key value)
  rbt  := rbtree

Evaluates (proc key val) for every association key -> value in the rbtree, in ascending order.

# rbtree-for-eachr

(rbtree-for-eachr proc rbt)
  proc := lambda (key value)
  rbt  := rbtree

Evaluates (proc key val) for every association key -> value in the rbtree, in descending order.

# rbtree-fold

(rbtree-fold proc seed rbt)
  proc := lambda (key value seed)
  rbt := rbtree
=> any

Folds the rbtree in ascending order.

# rbtree-foldr

(rbtree-foldr proc seed rbt)
  proc := lambda (key value seed)
  rbt := rbtree
=> any

Folds the rbtree in descending order.

# rbtree->list

(rbtree->list rbt)
  rbt := rbtree
=> list

Returns a list with all the associations in the rbtree, in ascending order.

# rbtree->listr

(rbtree->listr rbt)
  rbt := rbtree
=> list

Returns a list with all the associations in the rbtree, in descending order.

# list->rbtree

(list->rbtree cmp lst)
  cmp := lambda (x y); comparison function
  lst := alist
=> rbtree

Creates a new rbtree from an associative list.

# in-rbtree

(in-rbtree rbt)
  rbt := rbtree
=> iterator

Creates an iterator over the rbtree.

# in-rbtree-keys

(in-rbtree-keys rbt)
  rbt := rbtree
=> iterator

Creates an iterator over the rbtree keys.

# in-rbtree-values

(in-rbtree-values rbt)
  rbt := rbtree
=> iterator

Creates an iterator over the rbtree values.

# string-cmp

(string-cmp a b)
  a, b := string
=> fixnum

Comparison function for lexicographic string ordering.

# symbol-cmp

(symbol-cmp a b)
  a, b := symbol
=> fixnum

Comparison function for lexicographic symbol ordering.

# symbol-hash-cmp

(symbol-hash-cmp a b)
  a, b := symbol
=> fixnum

Comparison function for symbol ordering based on their hashes; ties are broken by lexicographic ordering.

# Sourceable Representation

# print-representation

(print-representation obj [port = (current-output-port)] [options = (current-representation-options)])

print-representation is a function (also available with the short-hand name pr) that takes an object, optionally a port and a table of options, and displays on that port source-code representation of the object that can be evaluated back into an equivalent object.

Behavior of print-representation can be specialized for new classes of objects by defining new methods on :pr, as in:

(defmethod {:pr my-class}
  (lambda (self port options)
    ...))

# pr

(defalias pr print-representation)

Same as print-representation.

# prn

(prn ...)

prn does the same as pr then follows with a newline.

# repr

(repr obj [options = (current-representation-options)])

repr does not take a port as argument and instead returns the representation as a string.

# representable

(defclass representable ())

representable is an abstract mixin class that defines a method for :pr. By default, if a class does not provide its own implementation, that method will call print-unrepresentable-object.

# print-unrepresentable-object

(print-unrepresentable-object obj [port = (current-output-port)] [options = (current-representation-options)])

print-unrepresentable-object is a helper function to use as fallback for objects that can't otherwise be displayed.

# default-representation-options

(def default-representation-options)

default-representation-options is the default table of options. No options are currently defined, and the default table is currently empty. In the future, options may be defined for pretty-printing, etc.

# current-representation-options

(current-representation-options [options])

current-representation-options is a parameter returning the current options, and initially returns the default-representation-options.

# display-separated

(display-separated lst [port = (current-output-port)]
                   [prefix: prefix = ""]
                   [separator: separator = " "]
                   [suffix: suffix = ""]
                   [display-element: disp = display])

display-separated is a helper function that takes a list of objects, an optional port, and as keywords a prefix: string (empty by default), a suffix: string (empty by default), a separator string (defaulting to a single space " "), and a display-element: function (the function display by default), and displays each element of the list with the given prefix, suffix, separator and display function.

# Type Descriptor Utilities.

# object-type

(object-type ...)

Please document me!

# type?

(type? ...)

Please document me!

# type-id

(type-id ...)

Please document me!

# type-name

(type-name ...)

Please document me!

# type-super

(type-super ...)

Please document me!

# type-descriptor?

(type-descriptor? ...)

Please document me!

# type-descriptor-mixin

(type-descriptor-mixin ...)

Please document me!

# type-descriptor-fields

(type-descriptor-fields ...)

Please document me!

# type-descriptor-plist

(type-descriptor-plist ...)

Please document me!

# type-descriptor-ctor

(type-descriptor-ctor ...)

Please document me!

# type-descriptor-slots

(type-descriptor-slots ...)

Please document me!

# type-descriptor-methods

(type-descriptor-methods ...)

Please document me!

# Shared-structure Equality.

# equal-shared?

(equal-shared? ...)

Please document me!

# Shuffling

# shuffle

(shuffle ...)

Please document me!

# vector-shuffle

(vector-shuffle ...)

Please document me!

# vector-shuffle!

(vector-shuffle! ...)

Please document me!

# String utilities

# string-split-prefix

(string-split-prefix ...)

Please document me!

# string-trim-prefix

(string-trim-prefix ...)

Please document me!

# string-split-suffix

(string-split-suffix ...)

Please document me!

# string-trim-suffix

(string-trim-suffix ...)

Please document me!

# string-split-eol

(string-split-eol ...)

Please document me!

# string-trim-eol

(string-trim-eol ...)

Please document me!

# +cr+

(def +cr+)

Please document me!

# +lf+

(def +lf+)

Please document me!

# +crlf+

(def +crlf+)

Please document me!

# string-subst

(string-subst str old new [count: count = #f])
  str   := string
  old   := string
  new   := string
  count := fixnum
=> string

In str replace the string old with string new. The procedure accepts only a fixnum or #f for count.

• count > 0 limit replacements
• count #f no limit
• count <= 0 return input

# Synchronized Data Structures.

# make-sync-hash

(make-sync-hash ...)

Please document me!

# sync-hash?

(sync-hash? ...)

Please document me!

# sync-hash-get

(sync-hash-get ...)

Please document me!

# sync-hash-ref

(sync-hash-ref ...)

Please document me!

# sync-hash-key?

(sync-hash-key? ...)

Please document me!

# sync-hash-put!

(sync-hash-put! ...)

Please document me!

# sync-hash-remove!

(sync-hash-remove! ...)

Please document me!

# sync-hash-do

(sync-hash-do ...)

Please document me!

# Text Utilities

# include-text

(include-text ...)

Please document me!

# Thread utilities

# primordial-thread-group

(primordial-thread-group ...)

Please document me!

# thread-group->thread-list*

(thread-group->thread-list* ...)

Please document me!

# all-threads

(all-threads ...)

Please document me!

# thread-dead?

(thread-dead? ...)

Please document me!

# thread-group-kill!

(thread-group-kill! ...)

Please document me!

# thread-raise!

(thread-raise! ...)

Please document me!

# thread-abort!

(thread-abort! ...)

Please document me!

# thread-abort?

(thread-abort? ...)

Please document me!

# thread-async!

(thread-async! ...)

Please document me!

# on-all-processors

(on-all-processors ...)

Please document me!

# Timeouts

# make-timeout

(make-timeout ...)

Please document me!

# UUIDs

# UUID

(UUID ...)

Please document me!

# uuid-length

(uuid-length ...)

Please document me!

# uuid::t

(uuid::t ...)

Please document me!

# make-uuid

(make-uuid ...)

Please document me!

# uuid?

(uuid? ...)

Please document me!

# uuid=?

(uuid=? ...)

Please document me!

# uuid-hash

(uuid-hash ...)

Please document me!

# uuid->u8vector

(uuid->u8vector ...)

Please document me!

# u8vector->uuid

(u8vector->uuid ...)

Please document me!

# uuid->string

(uuid->string ...)

Please document me!

# string->uuid

(string->uuid ...)

Please document me!

# random-uuid

(random-uuid ...)

Please document me!

# Functional utilities

Collection of mixed purpose higher-order functions.

# always

> (def fn (always 5))
> (list (fn) (fn))
=> (5 5)

> (def fn (always (lambda () "hi")))
> (fn)
=> "hi"

> (def fn (always random-integer 10)
> (list (fn) (fn))
=> (4 3)

Creates a lambda which returns the same value or calls always the same function with the same arguments.

# repeat

> (repeat 2 5)
=> (2 2 2 2 2)

> (repeat (lambda () 10) 2)
=> (10 10)

> (repeat random-integer 3 10)
=> (8 3 5)

Repeat value or call function N times and return the result as list.