Stories with Tag module

• Whenever – typed and DST-safe datetimes for Python

  permalink

  Posted: 2025-04-13 09:12:19

  Verbose tl;dr

  Whenever is a Python library providing a Whenever type for representing date and time values in a more robust and intuitive way than native Python types. It's particularly focused on handling Daylight Saving Time (DST) transitions correctly and consistently, avoiding ambiguities and errors common with other approaches. Whenever objects store datetimes as UTC timestamps internally, but allow users to interact with them in local time using a specified timezone. They offer convenient methods for performing date and time arithmetic, comparisons, and formatting, while transparently managing DST transitions behind the scenes. This simplifies working with recurring events or schedules that span DST changes, eliminating the need for complex manual adjustments. The library aims to provide a clear and dependable way to manage date and time information across different timezones and DST rules.

  The Python library whenever introduces a new approach to handling datetimes, specifically designed to address the complexities and ambiguities often associated with time zones and Daylight Saving Time (DST) transitions. It aims to provide a robust and intuitive way to represent and manipulate points in time, regardless of the user's current locale or the vagaries of time zone rules.

  Central to whenever is the concept of "typed datetimes." This means that datetime objects are not simply naive representations of a date and time, but are explicitly tagged with a specific time zone or UTC offset. This typing eliminates ambiguity about the intended moment in time, ensuring consistent calculations and comparisons, especially across different time zones. Moreover, whenever distinguishes between "wall clock times" and "absolute times." A wall clock time refers to the time displayed on a clock in a specific location, which can be affected by DST transitions. An absolute time, on the other hand, represents a fixed point on the timeline, independent of any time zone or DST. This distinction allows whenever to handle DST transitions gracefully, preventing errors that can occur when switching between standard time and DST.

  whenever provides several key features:

  • Explicit Time Zone Handling: Datetimes are always associated with a specific time zone, either by name (e.g., "America/New_York") or by a fixed UTC offset. This ensures clarity and avoids ambiguity in calculations.
  • DST Safety: The library is explicitly designed to handle DST transitions correctly, preventing errors that can arise from ambiguous or non-existent times during these transitions. It can accurately represent and calculate times during the "fall back" transition when the clock moves back an hour.
  • Intuitive API: whenever offers a simplified and consistent API for working with typed datetimes, making it easier to perform common operations such as time zone conversions, comparisons, and arithmetic.
  • Serialization: The library supports serialization of typed datetimes to and from various formats, ensuring that the time zone information is preserved. This is crucial for storing and exchanging datetime data.
  • Interoperability with other libraries: whenever integrates with existing datetime libraries like pendulum and pytz, allowing developers to leverage its features while working within familiar environments.

  By combining typed datetimes with a clear distinction between wall clock and absolute times, whenever aims to provide a more robust and reliable foundation for handling datetime data in Python, particularly in applications where accurate and unambiguous timekeeping is essential. It addresses the shortcomings of traditional datetime handling by explicitly addressing time zone complexities and DST transitions.

  • Python
  • DateTime
  • Date
  • time
  • Library
  • module
  • DST
  • daylight saving time
  • TimeZone
  • typed
  • Type Hints
  • Static Typing
  • mypy

  Summary of Comments ( 61 )
  https://news.ycombinator.com/item?id=43671308

  Verbose tl;dr

  Hacker News users generally praised the whenever library for its focus on type safety and handling of daylight saving time (DST), which are common pain points in Python's datetime handling. Several commenters expressed interest in its approach using tagged unions for representing different kinds of time specifications. Some raised questions about the practical implications of whenever's immutability, particularly concerning performance in tight loops and modification of existing datetime objects. The discussion also touched upon alternatives like pendulum and arrow, with some users suggesting whenever offered a fresh perspective on a persistent problem. A few commenters expressed skepticism about the library's complexity and the potential for over-engineering, preferring simpler solutions where possible.

  The Hacker News post about Whenever, a library for typed and DST-safe datetimes in Python, has generated a moderate amount of discussion, with a focus on existing solutions and the specific problems Whenever aims to address.

  Several commenters point towards existing libraries and built-in functionalities in Python that already address some of the issues Whenever tackles. One commenter highlights the zoneinfo module introduced in Python 3.9, suggesting it provides similar timezone handling capabilities. Another mentions the Pendulum library as a potential alternative that offers user-friendly datetime manipulation. A third points out that the datetime objects in Python already store timezone information, questioning the necessity of a new library.

  There's a discussion about the complexities of timezone handling in general. One commenter emphasizes the inherent difficulty of working with timezones and DST, suggesting that a comprehensive solution is challenging to achieve. Another adds to this by mentioning the "local time" ambiguity during DST transitions, where a specific time can exist twice or not at all, highlighting a common pain point.

  The core value proposition of Whenever, namely its type safety, is also discussed. One user expresses appreciation for the static typing aspect, which can help prevent errors related to timezone handling at compile time. This resonates with another commenter who also sees value in the type hints provided by the library.

  Finally, some commenters express skepticism about the library's usefulness. One suggests that using UTC consistently and only converting to local time for display purposes is a simpler approach. This sentiment is echoed by another who advocates for sticking with UTC and formatting time zones on output as a more straightforward solution.

• How Janet's PEG module works

  permalink

  Posted: 2025-04-11 02:04:52

  Verbose tl;dr

  Janet's PEG module uses a packrat parsing approach, combining memoization and backtracking to efficiently parse grammars defined in Parsing Expression Grammar (PEG) format. The module translates PEG rules into Janet functions that recursively call each other based on the grammar's structure. Memoization, storing the results of these function calls for specific input positions, prevents redundant computations and significantly speeds up parsing, especially for recursive grammars. When a rule fails to match, backtracking occurs, reverting the input position and trying alternative rules. This process continues until a complete parse is achieved or all possibilities are exhausted. The result is a parse tree representing the matched input according to the provided grammar.

  This blog post provides a comprehensive explanation of the inner workings of Janet's Parsing Expression Grammar (PEG) module. It begins by highlighting the efficiency and simplicity of PEG parsers, particularly their linear parsing time and lack of separate lexing/scanning phases. The post then delves into the specific implementation within the Janet programming language.

  The core of Janet's PEG module revolves around a compiled bytecode representation of the grammar rules. This bytecode is executed by a virtual machine, allowing for rapid parsing. The post meticulously details the various bytecode instructions used in this process, including char, set, any, range, choice, sequence, repeat, not, behind, ahead, and grammar. Each instruction's functionality is thoroughly described, along with how it manipulates the input string and internal parser state.

  The char instruction, for example, checks for a specific character at the current input position. set checks for membership within a set of characters. any consumes any single character. range matches a character within a specified Unicode range. Control flow instructions like choice implement ordered choice, attempting each alternative rule sequentially until a match is found. sequence ensures that all sub-rules match in order. repeat allows for matching a rule multiple times, with variations for specifying minimum and maximum repetitions. Lookahead assertions are implemented via ahead (positive lookahead) and behind (positive lookbehind) which check for matches without consuming input. Negative lookahead is achieved with the not instruction. Finally, the grammar instruction enables recursive grammar definitions, allowing for complex nested structures.

  The post emphasizes the use of a backtracking mechanism to handle alternative rules and optional elements. This backtracking ensures that all possible parsing paths are explored until a successful match is found or all options are exhausted. The parser maintains an internal state that includes the current input position and a capture stack to store matched portions of the input. Upon successful parsing of a rule, the captured input fragments are assembled into a parse tree, representing the hierarchical structure of the matched input.

  The post concludes by highlighting the performance benefits of Janet's compiled PEG approach compared to interpreted PEG parsers. The bytecode execution provides a significant speed advantage. This combined with the flexibility and expressiveness of PEGs makes Janet's PEG module a powerful tool for parsing various data formats and creating domain-specific languages. The compact and understandable bytecode format further enhances the maintainability and debuggability of the parser.

  • Janet
  • PEG
  • Parsing Expression Grammar
  • parser
  • programming language
  • compiler
  • parsing
  • module
  • How-to
  • Tutorial

  Summary of Comments ( 2 )
  https://news.ycombinator.com/item?id=43649781

  Verbose tl;dr

  Hacker News users discuss the elegance and efficiency of Janet's PEG implementation, particularly praising its use of packrat parsing for memoization to avoid exponential time complexity. Some compare it favorably to other parsing techniques and libraries like recursive descent parsers and the popular Python library parsimonious, noting Janet's approach offers a good balance of performance and understandability. Several commenters express interest in exploring Janet further, intrigued by its features and the clear explanation provided in the linked article. A brief discussion also touches on error reporting in PEG parsers and the potential for improvements in Janet's implementation.

  The Hacker News post "How Janet's PEG module works" sparked a discussion thread with several insightful comments focusing primarily on parsing techniques, the Janet programming language, and comparisons to other parsing tools.

  One commenter highlighted the elegance of parsing expression grammars (PEGs) and their ability to express complex grammars concisely, contrasting them favorably with regular expressions for certain parsing tasks. They emphasized the power and flexibility of PEGs, particularly when dealing with structured data. They also expressed appreciation for the author's clear explanation of Janet's PEG implementation.

  Another commenter discussed the unique aspects of Janet as a programming language, particularly its embedded nature. They pointed out how this feature makes it well-suited for tasks where integrating a scripting language is beneficial. They also mentioned Janet's use of immutable data structures as a significant advantage.

  A subsequent comment delved into the implementation details of Janet's PEG module, touching upon memory management and performance considerations. This comment sparked a brief exchange about the trade-offs between different parsing approaches and their suitability for various applications.

  Further down the thread, a commenter compared Janet's PEG implementation to other parsing tools and libraries, mentioning tools like Parsec and LPEG (Lua Parsing Expression Grammars). They discussed the strengths and weaknesses of each, offering insights into their suitability for different parsing scenarios. This comparison provided a broader context for understanding Janet's approach.

  Several other comments expressed general appreciation for the article and the clarity of its explanation. Some users mentioned their interest in exploring Janet further based on the information presented.

  The overall sentiment in the comments was positive, with many users praising the article's educational value and the insights it provided into Janet's PEG implementation. The discussion offered a valuable perspective on parsing techniques, language design, and the trade-offs involved in different parsing approaches.