Features Found In Every Program edit

• A command that returns a guaranteed unused command name, optionally using a template for the name.
• An [lshift] command: return the first element of a list stored in a variable, removing it from the list and updating the variable (surely this would be faster in C?)

 proc lshift varName {
    upvar 1 $varName L
    set res [lindex $L 0]
    set L [lrange $L 1 end]
    set res
 } ;# RS who likes to roll his own ;-) Alternatively, using [K]:
 proc K {x y} {set x}
 proc lshift varName {upvar 1 $varName L; K [lindex $L 0] [set L [lrange $L 1 end]]}

 set list [lassign $list aVar]

• BR - finally: The finally part of try/catch/finally. Manually writing correct code for resource deallocation and re-throwing an error is somewhat tedious and error-prone (see example and a simple proposal on the catch page). DKF: I'd quite like this too, but 8.5 now gives you enough bits and pieces to script this.
• RS 2007-05-25 - In Tcl scripts used in pipes, I frequently code:

 proc puts! str {if [catch {puts $str}] exit}

 error writing "stdout": broken pipe
    while executing
 "puts ...

Missing Functionality edit

Critical Missing Functionality

1. What we need here is a list of needs that have not even been written yet, as far as the writer knows.
2. Documentation and examples based on Functionality of frame and toplevel -container to enable swallowing of external X desktop applications, xterms, etc. (DKF: Some good examples of doing this here on the wiki would be good too...)
3. Better Data Structure support, with garbage collection where appropriate (8.5 brings dict)
4. True Multi-dimensional arrays (does nap satisfy here or BLT's data vectors? How would nested lists be insufficient?) (DKF: Also, dicts are nestable)
5. Garbage Collected Reference style data objects (this is possible: specifically we need to stop Tcl from losing references as easily as it does). [This is a controversial issue. Tcl does some things better than other languages because it does not rely on references for constructing data structures.] Jim has garbage-collected references.
6. Better Cross-platform ability to print out GUI components (DKF: Nice, but seems to be hard due to different printing models on different platforms. This awaits someone with serious amounts of time to work on it...)
7. Rich clipboard types (DKF: We already support this on X, though you have to do more work yourself. It's on Win or OSX where I think this is pressing, and yet tricky.)
8. Plugin style browser functionality, to allow seamless download and launch of Tcl/Tk application without a seperate install step (perhaps making use of starpacks?)
9. More help from tclpro's ProWrap to figure out what extensions can be included and which can't and help resolve the issue
10. An http client package that supports async requests (DKF: It already does; it's just that DNS lookups are blocking...)
11. An http client package that supports persistent connections (DKF: Isn't someone working on an enhanced http package that supports HTTP/1.1?)
12. Lazy evaluation support (DKF: I think we shouldn't do this; we should just say that Tcl is an eager language.)
13. Transmission of events/bindings between subwidgets of a megawidget
14. Support for lists of pure strings (more details is needed here)
15. Generate procs from a string (why doesn't eval fill this need? Or proc?) (DKF: Or apply?)
16. Documentation development support in the core
17. Cross-platform ability in Tcl to get just one character from stdin. (DKF: We can do it using read, but currently need hackery to put stdin into raw mode first. TIP#160 covers this, but I've been too busy to work on it...)
18. Named colors (similar to named fonts) and the system colors with names. (There is TIP#154 [1], but Tile may have obsoleted that.)
19. Option sets
20. Ability to use all Windows (or other OS) native widgets - in the way that the MacOS X team is providing Aqua support (See note at bottom)
21. general software-generated event dispatch system, with value substitution and bindtags management, independent of Tk. Michael McLennan has something called a trigger command that may be relevant.
22. Continuations combined with Tcl level events (What are continuations?) ("... a way to nest calls to VWait in a way that the outer calls can wake before the inner calls do. That's the difference between continuations and subroutines.)
23. ONC RPC/Sun RPC and rpcgen support (DKF: In the core? Why? Do it as an extension first, please.)
24. Ability to use an internally generated bitmap as a Tk cursor.
25. Code to recognize a master pkgIndex.tcl, maintained so as to allow Tcl to skip the pkgIndex.tcl discovery process (DKF: How do modules interact with this?)
26. Introspective access to line number of code being executed. (TIP #280 [2] provides this.)
27. Introspective access to commands associated with a particular loaded package
28. Some form of synchronization, inter-process (i.e. the lock/mutex/.. is visible in other processes). Something like the mutexes in thread, but then not just inside a process. You can see people find ways around this here How do I manage lock files in a cross platform manner in Tcl and Serializing things via file locks. Note the work involved to make something that will hopefully work on all platforms, and the trouble (what if we crash, the lock file remains and everything hangs; how do we find a free port for the socket, and how do other invocations of the same program know to use the same port, etc). This is difficult, and very difficult to do cross-platform, which is exactly why you'd hope your tool(s) would make it easy. Tcl should... (DKF: Tcl should... leave this to an extension?)

Important Missing Functionality

One or more Object Oriented Extensions

1. incr Tcl [This one is on its way into the core distribution - if only someone steps forward and leads the work effort to make it happen.]
2. stooop [This one is now in Tcllib ].
3. pool
4. XOTcl
5. Snit's Not Incr Tcl
6. DKF: Also TclOO.

One or more Windowing Extensions

1. Tk
2. wxTcl (is that the right name?)
3. Fltk Tcl binding
4. Gnocl Gtk-Binding

One or more Meta-command/megawidget Extensions

1. incr Tk
2. mkWidgets

One or more additional Extensions that add widgets to Tk

1. BWidgets
2. BLT
3. Tix [3] [4]
4. EffTcl (from the book Effective Tcl/Tk Programming)
5. One of the HTML rendering widgets like TkHTML
6. an OpenGL based widget set
7. a multi-column listbox widget like mclistbox, but with image capability as well
8. incr Widgets
9. Drag and Drop support such as TkDND [5] [6] [7]
10. TkTable
11. The vu widget set (part of TkTable SF project, but different widgets)
12. A combobox
13. A tree widget TkTreeCtrl
14. A progress bar (This should use native progressbars on Windows and OS X)
15. A tab notebook

Extensions of other types

1. CriTcl
2. Img
3. Expect
4. TclX
5. tcllib
6. Snack
7. tclSOAP
8. tclxml
9. tclDOM
10. tclvfs
11. tcl threads
12. Provide http 1.1 support in Tcl's default http support (see TclSOAP for a beginning towards such support).

Specific Functionality available in some existing extension

1. An ftruncate or truncate command to truncate an open file to zero bytes or optionally to X bytes. (This is now chan truncate.)
2. A general database interface, under which a person could plug in specific hooks to Oracle, Sybase, Postgres, msql, odbc, etc. without having application changes needing to be made. Work on this has gone on with tclodbc and [fill in other extension names here] (DKF: SQLite has a lot of how I think such an interface should work.)

Useful Missing Functionality

Extended digit math support

1. Mpexpr (DKF: Note that this extension will not be co-distributed with Tcl itself for license reasons. Basing something off libtommath would make for best integration with Tcl, and the license is nice and friendly...)
2. math::bigfloat which is included in tcllib (for floating-point numbers)

Statistics calculation support

Numerical analysis support

Lambda In Tcl

Other

1. LDAP
2. Trf
3. Memchan (Does chan create support this in the core now? DKF: Should be most of what you need; remaining bits can probably be scripted...)
4. tkpiechart
5. a port of the various widgets available for Perl/Tk but which are not currently available for Tcl/Tk (DKF: Being...?)
6. UDP and multicast sockets handling (in the core - hopefully as versatile and elegant as the current sockets implementation) (DKF: Question is, is the channel idiom right for this? If not, a new idiomatic messaging layer is needed, and that's tricky to think of.)
7. Tiled backgrounds in widgets
8. Ability to attach user data to an event - particularly virtual events - so they could be used as general message passing mechanism. (DKF: Done in 8.5 for virtual events.)
9. Ability to treat an event more like an object
10. Ability to overload expr's operators, to add things like complex number calculation support. (DKF: This is hard to do. Very very hard.)
11. tclhttpd (What in the world does this mean?) (a [web server] written in pure-Tcl, multi-threaded, easy to deploy and to use ala PHP)
12. Ability to execute Tcl commands from a command line invocation of Tcl (Currently, tclsh leaves all command line switches to the domain of the tcl script being executed - changing this would break existings scripts. It is rather trivial to write a tcl script that provides this kind of functionality - see owh - a fileless tclsh for one example)
13. Ability to generate image and font names so collisions can be avoided without reliance on remembering to specify some sort of prefix. (DKF: For images, this is trivial; just leave the name out from image create...)
14. Ability to apply some proc/command to each character of a string without having to a) split the string into a list of single character elements or b) looking up the string index each time through a loop. The first means that huge strings have to be duplicated in memory and the second means that huge strings require longer lookups than needed. [Actually, the second also duplicates the string in memory, as the string gains an internal representation for fast indexing.] Basically, the idea would be a means of treating a string as if it were a C/C++ byte array, only ideally the array would treat unicode characters as unique elements; ie $stuff(index) would hyperquickly find the right character. (DKF: Splitting into individual characters is specially optimized anyway; doing better now requires writing a [foreachCharacter] command.)

proc variables { args } {
  foreach var $args { uplevel 1 [ list variable $var ] }
}

proc my-source { file } {
  source [ file join [file normalize [file dirname [info script]]] $file ]
}

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