ycl

Installation  edit

fossil clone http://chiselapp.com/user/pooryorick/repository/ycl ycl.fossil

tclsh /path/to/opened/fossil/packages/ycl/bin/yclrun myscript.tcl

tclsh /path/to/opened/fossil/packages/ycl/bin/yclsh

Usage  edit

ycl/bin/ycl  edit

synopsis

ycl/bin/ycl cmd package command ?args?

Example

$ tclsh /cygdrive/c/Users/yorick/Documents/ycl/src/packages/ycl/bin/ycl cmd 'math rand' randprint_256
BUV9z#=Zu=dAi@y^ytLk1LrTKRp35tbqN^LgqkH7Z6

Contents  edit

chan

connect

Connect the output of one channel to the input of another. Uses a separate thread to avoid deadlocks.

tee

Transforms a channel into another channel whose output is asynchronously duplicated to a third channel.

chunked

A reflected channel that wraps another channel, translating its contents from HTTP chunked format. Written as a reflected channel instead of a channel transform so that the wrapped channel can persist after the chunked wrapper is closed. This feature is useful for persistent HTTP connections.

clib pushTransform

A Critcl C function that can be used by another Critcl package to push a channel transform onto a channel:

package require {ycl chan clib}
critcl::api import ycl_chan_clib
critcl::cproc someproc ... {
        pushTransform(..., mytransform ...)
        ...
}

int pushTransform(Tcl_Interp interp
        ,ClientData clientData
        ,ycl_chan_transform_eofProc eof
        ,ycl_chan_transform_closedProc closed
)

int transform(Tcl_UniChar uchar ,Tcl_DString output)

wrap

A skeleton reflected channel that wraps another channel.

chan clib

package require {ycl chan clib}
::critcl::api import ycl_chan_clib 0.1

filter(Tcl_Interp *interp ,Tcl_Channel inchan ,Tcl_Channel outchan ,(process)(Tcl_Interp *interp ,Tcl_UniChar *uchar ,Tcl_DString *output))

Filters data as it passes from inchan to outchan. process recieves one character and modifies output , which is then written to outchan.

comm

ycl comm http

An http client that makes use of coroutines and reflected channels.

context

package require {ycl context}
namespace import [yclprefix]::context::context

proc fly {ns args} {
    puts  "$ns is flying!"
}

proc nofly {ns args} {
    puts "$ns can't fly!"
}

context bird
bird method fly
bird fly

bird derive eagle
eagle fly

bird derive emu
emu method fly nofly
emu fly

#remove emu's restriction
set emumethods [namespace ensemble configure emu -map]
set emumethods [dict remove $emumethods fly]
namespace ensemble configure emu -map $emumethods

emu fly

coro

async

A distillation of the ycl coro relay system into three commands: wait, reply, and async. This provides all the functionality of Javascript promises but without all the extra syntax.

event

An event loop for coroutines. Tries to play nice with Tcl's event loop. This system was created to avoid the performance penalty of using Tcl's event loop as a queue for communication between coroutines.

relay

A small but complete system that allows cooperating coroutines to make and deliver orders amongst themselves.

eav

eav

An entity-attribute-value system built on sqlite, featuring a Tcl-ish interface and query capabilities, and traces for maintaining data constraints and reacting in other ways to record updates.

Daerth

Daerth

creates and manages minions of threaded asynchronous pipelined backpressure-mediated compute stations.

dict

search

Like lsearch, but searches keys, and returns results in reverse order.

setm

Like dict set, but doesn't deduplicate other keys in the dictionary.

unsetm

Like dict unset, but doesn't deduplicate other keys in the dictionary.

dir

package require {ycl dir}
namespace import [yclprefix]::dir

copynode

Copy a file or directory into an archive location, faithfully duplicating any symbolic links, recursively, in the path of the file. Does not copy the contents of a directory, just the directory node itself, which may be a symbolic link. In order to accomodate arbitrary symbolic links in the path of the file or directory, It is placed in the archive at the same absolute location, with the archive directory as the root.

duplicates

find duplicate files

deduplicate

remove duplicate files

iter

iterate over items in a directory tree.

for item in [dir iter /my/dir] {
    #do stuff
}

listing

A drop-in replacement for glob that provides a new type specifier, +hidden, to include hidden files all results.

entropy

exec

filter ?exec command? script

Invoke a new interpreter and evaluate script in it. Returns a read/write channel connected to the new process. If exec command is provided, it must return a new ineractive interpreter.

invoke

invoke a child program and asynchronously handle stdio, stderr, and exit code. See example at [open].

iter

package require {ycl iter}

file

iterate over a file, by line or arbitrary function

string

iterate over the characters in a string

format

sh::shtotcl

converts the words of a value in sh syntax to a Tcl list.

iter::for

package require {ycl iter for}

for ... in

a convenient loop construct for working with iterators

knit

matrix

math

flip

Randomly produces a 1 or 0. The output is intended to have the same high entropy as as true random numbers and to be suitable for cryptographic use. This command is analagous to /dev/random.

rng

Cryptogphic random number generator using a seed produced by flip. Analagous to /dev/urandom.

rand

A cryptographically-strong alternative to the built-in rand() function.

ns

package require {ycl ns}

dupcmds

Copy all commands in a namespace to another namespace, refusing to overwrite any existing commands, and ignoring commands named in in $args. In contrast to oo::copy <cloned>, if a command is both an alias and a procedure, it is treated as an alias.

ensemble duplicate

Copy a namespace ensemble, and if necessary, the namespace that's backing it, along with any child namespaces, recursively. Also replaces in the ensemble map occurrences of the old ensemble name with the new ensemble name. dupensemble can be used as the simplese form of object system, where each namespace hierarchy is treated as an object. Tcl's copy-on-write semantics make this system much more efficient than one would expect at first blush. dupensemble is used by ycl::shelf

ensemble subcommands

List the currently-available subcommands of a namespace ensemble.

dupvars

duplicates all variables in a namespace to another namespace

package

vcomp

like package vcompare, but accepts just about anything as a version string.

parse

tcl commands

Split a Tcl script into its components. This is scriptsplit

tcl iter

Uses ycl coro relay to deliver the comands in a script read from a channel.

tcl words

Split a Tcl command into its components. This is cmdSplit.

tcl wordparts

Split a logical word from a Tcl command into its literal, escape-sequence, and substitution components. This is wordparts.

tcl stream

Incrementally parse a Tcl script from a channel.

xml

An xml parser based on ycl parser graph. -relax true enables a forgiving mode when trying to make it through an document.

xml util validCharExpr varname

Returns an expression that evaluates to true if the character in $varname is a valid XML character, and false otherwise.

xml util encodeInvalidChars inchanname outchanname

A filter between channels that converts characters that are invalid in XML to their XML character representations. Accelerated with Critcl when it's available. Uses ycl chan clib filter.

xml util chanEncodeInvalidChars

A stacked channel that encodes invalid XML characters into character entities. Uses ycl chan clib pushTransform.

parser

package require {ycl parser graph}

graph

A framework for extracting graphs from data. -transient false instructs the parser to leave behind a hierarchy of namespaces representing the graph, and commands like children, path, and traverse provide an interface to the graph. This system facilitates the creation of parsers that ignore text outside the target syntax of a given parser.

interp

Adapted from Config file using slave interp.

proc

package require ycl::dir
namespace import [yclprefix]::dir

checkargs

functional documentation for procedures. Somewhat like tepam, with additional aspects of literate programming. Examples include ycl::dir::iter, and ycl::ns::object

alias

an analogue of interp alias that avoids the potential negative performance impact. In contrast to interp alias, extra arguments can not be tacked on to the alias.

lproc

Like proc, except that the body is a list of lists and no string representation of the body is generated.

tcl step

A drop-in replacement for proc that provides a pre-evaluation hook and an error handling hook for each command in the script.

struct

env

create, savigate, and manipulate hierarchical data structures. Implemented over tDOM.

quicktcl

shelf

string

package require {ycl string}

cmp

Like the Unix cmp command, compares two strings and returns the index at which they differ, or -1 if they are identical. Uses a bisect strategy for performance, and for memory efficiency does not extract substrings. Short-circuits when a difference is found.

shortmatch

same as string match, but return -1 if $string doesn't match, and the index of the last char of the shortest match if it does

dedent

remove common newline-whitespace

delimit

split (partition) a string into substrings using any combination of string, match, or regular expressions, returning both the substrings and the delimiters.

expand

Provides a macro syntax to expand substrings within a string by iteratively replacing a listed nested in the substring itself with items from the list. The idea is to generate code while keeping the original source code legible.

expand

Provides a concise syntax for embedding and expanding templates in text, the primary target being Tcl scripts. Based on ycl parser graph

template

Cut down the verbosity of string map by using the same name to obtain a value from a local variable and to map that value into the string, providing default delimiters, and by automatically quoting values with list. Example:

set a 5
set b 7
set expr {[set a]}
eval [template a b # c {
        set a @a@
        set b @b@
        expr {$a + $b + @expr@}

struct

nxs

Nested heterogeneous structures. Example: nxs get $mystruct l {0 3 1} d {name Bob friends} l 5. To set a nested vale: nxs set mystruct l {0 3 1} d {name Bob friends} = l end Jane. Extend the functions to additional types of nested structures by adding keys to nxs::get, nxs::set, and nxs::unset. To specialize the library, use ycl ns dupensemble to create a copy of it.

switch

lswitch

Like switch, but each pattern is a list of patterns to match against the item in string at the corresponding position. All switch options are supported.

test

cleanup1

Returns the current namespace to the state it was in before the test was run.

test sometest {} -body {
} -cleanup [cleanup1] -result ...

text

ftclp

Formats a string as a printable Tcl string. Non-printable characters are transformed into their most simple backslash-escaped representation, and backslash is also escaped.

tk_combobox_oakley

upobj

#! /bin/env tclsh

package require ycl::ns
namespace import ycl::ns::object
package require ycl::proc

namespace import ycl::proc::*method


upmethod die {} {} {} {
    puts "$_ dies."
}

object chessman import {name die}
chessman $ name unknown

namespace eval chessman {
    upmethod move {} {} {} {
        puts "$_ doesn't know how to move!"
    }
}

object pawn
pawn parent chessman
namespace eval pawn {
    upmethod move {} {} {} {
        puts "$_ is plodding forward"
    }
}

object knight 
knight parent chessman
namespace eval knight {
    upmethod move {} {} {} {
        puts "$_ gallops forward and to the side"
    }
}

object amazon
namespace eval amazon {
    upmethod move {args} {} {} {
        dict with args {}
        if {$as ni {knight queen}} {
            puts "$_ can not move as a $as"
        } else {
            puts "$_ is moving as a $as"
        }
    }
}

puts "chessman name is: [chessman $ name]"
# -> unknown

chessman move
# -> ::chessman doesn't know how to move! 

object pawn1 
pawn1 parent pawn
pawn1 move 
# -> ::pawn1 is plodding forward

puts "pawn1 name is: [pawn1 $ name]"
# -> unknown

pawn1 $ name {white a}
puts "pawn1 name is now: [pawn1 $ name]"
# -> white a

object knight1
knight1 parent knight
knight1 move 
# -> ::knight1 gallops forward and to the side 

object knight3
knight3 parent knight2
knight3 parent amazon
knight3 move as queen
knight3 move as bishop

visual

slides

A simple presentation system in Tk.

• Home
• Recent changes
• Help
• WhoAmI/Logout
• Create new page
• Random page
• Previous page
• Next page
• 
  
• Add comments
• Edit
• History
• Edit summary
• References