Forkhandles (4k)

Ropes4k is a Kotlin implementation of a Rope data structure. Ropes are optimized for heavy insert and delete operations. Unlike String, StringBuffer, or CharArray, Ropes do not copy the entire data set during these operations, making them significantly faster for large-scale modifications.

Use Ropes when:

• You need to perform frequent insertions, prepends, or deletions on large text sequences.
• You want to avoid the performance penalty of copying large amounts of data during modifications.

Avoid Ropes when:

• Your primary access pattern is random-access (getting characters by index), as the tree-based storage makes indexing slower than standard strings.

In the ForK ecosystem, TimeSource is used to decouple code from the system clock, enabling easier testing (e.g., simulating specific points in time) and better library composition.

Instead of using a heavy class or interface like java.time.Clock, TimeSource is defined as a simple typealias to a function that returns an Instant. This allows you to provide time sources using lambdas, function references (like Clock::now), or through function composition.

typealias TimeSource = () -> Instant

The GPLv3 includes specific provisions regarding patents:

• Grant of Patent License: Each contributor grants a non-exclusive, worldwide, royalty-free patent license under their essential patent claims to make, use, sell, offer for sale, import, and otherwise run, modify, and propagate the contents of their contributor version.
• Automatic Extension: If you convey a covered work and grant a patent license to some recipients, that license is automatically extended to all recipients of the covered work and works based on it.
• Prohibition on Discriminatory Licenses: You may not convey a covered work if you are part of an arrangement with a third-party distributor where you make payments based on the extent of conveying and the third party grants discriminatory patent licenses to recipients.

Tx4k manages typesafe, programmatic transaction boundaries using three primary abstractions:

• Transactor: The orchestrator. It manages the lifecycle of a transaction: creating a resource, starting the transaction, wrapping the resource in an API, passing that API to your application code, and finally committing or rolling back based on the outcome.
• Resource: The underlying transactional object being managed (e.g., a JDBC connection or an in-memory serializable transaction implementation).
• API: The abstraction layer that wraps the Resource. This is the interface your application code interacts with to perform transactional operations.

This project is licensed under the GNU General Public License version 3 (GPLv3). This license governs how you may use, modify, and distribute the software. Key concepts include:

• The Program: The copyrightable work licensed under this license.
• Modified Version: A work created by copying from or adapting the original work.
• Covered Work: Either the unmodified Program or a work based on it.
• Conveying: Any propagation (distribution, copying, etc.) that enables others to receive copies. Mere network interaction without transferring a copy is not conveying.
• Corresponding Source: The preferred form of the work for making modifications, including all source code needed to generate, install, and run the object code, plus scripts to control those activities.

You can use the dir function to automatically create a file system structure. Within the dir block, you can define files using text() for text-based files or binary() for binary data. You can also nest dir() calls to create subdirectories.

To define content for a text file, set the content property to a String. For binary files, set the content property to an InputStream (e.g., using .byteInputStream()).

When using Automatic as the second argument to dir, the file system is created automatically upon definition.

val directory = dir("path", Automatic) {
    text("plainfile.txt") {
        content = "hello"
    }
    binary("binary.png") {
        content = "goodbye".byteInputStream()
    }

    dir("directory") {
        text("file2.html") {
            content = "<html/>"
        }
    }
}

// directory is created automatically
directory.delete()

If your program uses a terminal interface, it should output a short notice when starting in interactive mode. This notice should direct users to commands (e.g., show w and show c) that display the appropriate parts of the General Public License. For GUI applications, this information is typically placed in an about box.

<program>  Copyright (C) <year>  <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.