duke-git/lancet

Features

• Go Libraries - Provides a comprehensive extension of the Go standard library with reusable functions and data structures.
• Channel Flatteners - Provides utilities to flatten a stream of nested channels into a single continuous stream of values.
• Event Bus - Implements an event bus to decouple application components through a publish-subscribe mechanism.
• Least Recently Used Caches - Provides an in-memory LRU cache that automatically evicts the least recently used items.
• Go Generic Collections - Provides specialized Go data structures including LRU caches, priority queues, and thread-safe lists.
• Go Concurrency Utilities - Implements advanced synchronization patterns and channel-based data streams for asynchronous workflows in Go.
• Go Functional Programming Toolkits - Provides a toolkit for functional programming patterns such as currying and function composition in Go.
• Higher-Order Function Toolkits - Provides a toolkit for higher-order function composition, including currying and pipelining for modular logic.
• Channel Merging - Implements patterns for combining multiple Go data streams into a single output channel.
• Consumption Limiters - Implements primitives that restrict the number of elements consumed from a Go channel before closing.
• Channel Splitting - Implements primitives that duplicate a single input channel into multiple output channels for multiple consumers.
• Value-Based Stream Generation - Creates channels populated with static values or results from repeatedly executed functions.
• Asymmetric Encryption - Implements RSA asymmetric encryption and decryption including support for OAEP padding.
• RSA Signing Implementations - Creates and verifies digital signatures using RSA private and public keys.
• Cryptographic Hash Generation - Generates cryptographic digest values for strings, byte slices, or files using MD5, SHA, and SM3.
• Go Cryptography Implementations - Implements symmetric and asymmetric encryption, digital signing, and hashing using AES, RSA, and SM standards.
• HMAC Generation - Produces keyed-hash message authentication codes (HMAC) using MD5 and SHA algorithms.
• Keyed Locking - Synchronizes shared resource access by associating specific mutexes with unique identifiers to reduce lock contention.
• SM Standard Cryptography - Implements SM2 asymmetric encryption, SM3 hashing, and SM4 symmetric encryption.
• Symmetric Encryption - Provides symmetric data encryption using AES, DES, and GCM algorithms with various modes.
• Channel-Based Stream Processing - Implements lazy data pipelines using Go channels to manage asynchronous flow via fan-in and bridging patterns.
• Channel Racing - Provides concurrency primitives to read from multiple channels and return the first available value.
• Event Subscriptions - Manages event subscriptions with support for registering and removing listeners with priority and filtering.
• Function Execution Utilities - Wraps functions to provide execution control including debouncing, throttling, currying, and scheduling.
• File and Directory Operations - Provides a comprehensive set of functions to create, remove, copy, and manage files and directories.
• Predicate-Based Element Filtering - Removes elements from collections based on a predicate function or comparison against another list.
• CSV File Processing - Reads and writes tabular data between CSV files and slices or maps.
• Unique Value Collections - Provides set collections that ensure every element is unique with methods for existence checks.
• Enum Registries - Implements registries for named constants with validation and JSON marshaling support.
• Enum Membership Validators - Provides rules for confirming that input values belong to a predefined enumeration class.
• Insertion-Order Maps - Provides a map implementation that preserves the sequence of elements as they were inserted.
• Concurrent Map Implementations - Provides a map implementation safe for concurrent use by multiple goroutines.
• Parallel Stream Readers - Reads large files in chunks using parallel goroutines to stream lines into a channel.
• Lazy Stream Processing - Creates lazy streams from slices or channels to perform mapping, filtering, and reduction.
• List Set Algebra - Calculates union, intersection, and difference between lists, and checks for list equality.
• Slice Sorting Algorithms - Orders elements in a slice using QuickSort, MergeSort, or BubbleSort algorithms.
• Unique Identifier Generators - Implements RFC 4122 compliant version 4 universally unique identifier generation.
• Base64 Encoders - Converts values into standard, URL-safe, or raw Base64 strings, including JSON serialization for complex structures.
• Go Network Utilities - Offers lightweight helpers for HTTP requests, URL construction, and network interface discovery in Go.
• Operating System Interfaces - Provides capabilities to execute shell commands, manage environment variables, and retrieve system process information.
• Process Lifecycle Management - Provides utilities for starting, stopping, and monitoring system processes via PIDs and signals.
• Zip Archive Management - Provides utilities for creating zip archives from files or directories and extracting zipped content.
• Data Type Conversions - Transforms values between strings, booleans, integers, and floats with built-in error handling.
• FIFO Queues - Implements FIFO queues using array, linked, or circular data structures.
• File Read and Write Operations - Implements primitives for reading and writing file content as strings, bytes, or CSV formats.
• Generic Collection Implementations - Provides standard data structures implemented via interfaces to achieve type flexibility across collections.
• Slice and Map Type Converters - Transforms slices of structs into maps or maps into slices using custom iteratee functions.
• Random Primitives - Provides utilities for generating random integers, strings, UUIDs, and boolean values.
• LIFO Stacks - Implements LIFO stacks using array or linked-list backends.
• Object Cloning Techniques - Creates complete independent deep copies of items, including nested structures and maps.
• Binary Search Trees - Provides binary search tree structures for efficient data retrieval and sorted organization.
• Linear Data Structures - Maintains ordered collections of elements with standard insertion, deletion, and retrieval utilities.
• Function Currying - Transforms multi-argument functions into a series of single-argument functions through currying.
• Functional Pipeline Composition - Creates execution pipelines where the output of one function is passed as the input to the next.
• Slice Search Algorithms - Locates the index of a target value within a slice using linear or binary search.
• Asymmetric Key Management - Provides utilities for generating and saving RSA public and private key pairs to files.
• SM2 Key Management - Implements SM2 elliptic curve key pair generation for asymmetric encryption and decryption.
• File Hashing Utilities - Computes SHA-1, SHA-256, or SHA-512 cryptographic checksums for files.
• Copy-On-Write Lists - Manages lists using a copy-on-write strategy to ensure thread-safe reads and writes.
• Copy-On-Write Collections - Ensures thread-safe concurrent access to collections by duplicating the underlying storage during write operations.
• Error Wrapping Utilities - Provides enhanced error handling by wrapping errors with custom IDs, messages, and stack traces for better debugging.
• Event Bus Architectures - Provides a publish-subscribe mechanism that routes payloads to registered listener functions to decouple system components.
• Delayed Execution Utilities - Triggers functions to execute once after a specified duration has elapsed.
• Execution Debouncing - Implements function debouncing to prevent execution until a specified delay has passed since the last invocation.
• Function Retry Strategies - Executes tasks repeatedly until success or timeout using configurable linear or exponential backoff strategies.
• Struct-to-Map Converters - Uses Go reflection to extract fields and tags for converting structured objects into generic map representations.
• Panic Recovery Mechanisms - Implements a mechanism to catch and handle runtime panics similar to try-catch blocks.
• Sharded Maps - Implements maps partitioned into multiple segments with independent locks to minimize contention during concurrent access.
• Priority Queues - Implements priority queues for retrieving elements based on a specific priority.
• String Manipulation - Provides advanced string operations including Camel, Snake, and Kebab case conversion, padding, and substring extraction.
• Execution Duration Tracking - Captures the execution duration of functions to track performance and timing.
• Function Execution Throttling - Provides a mechanism to ensure a function is executed at most once per specified time interval.

Star history