All Projects → JuliaLang → Compat.jl

JuliaLang / Compat.jl

Licence: other
Compatibility across Julia versions

Programming Languages

julia
2034 projects

Projects that are alternatives of or similar to Compat.jl

mpx-es-check
Checks the version of ES in JavaScript files with simple shell commands
Stars: ✭ 15 (-82.56%)
Mutual labels:  compatibility
Swiftuix
Extensions and additions to the standard SwiftUI library.
Stars: ✭ 4,087 (+4652.33%)
Mutual labels:  compatibility
Graphene
Graphene / Graphene-SGX - a library OS for Linux multi-process applications, with Intel SGX support
Stars: ✭ 614 (+613.95%)
Mutual labels:  compatibility
trivial-with-current-source-form
Helps macro writers produce better errors for macro users
Stars: ✭ 22 (-74.42%)
Mutual labels:  compatibility
wcecl
Allows to run Windows CE applications on Windows!
Stars: ✭ 54 (-37.21%)
Mutual labels:  compatibility
Php Compat Info
Library that find out the minimum version and the extensions required for a piece of code to run
Stars: ✭ 338 (+293.02%)
Mutual labels:  compatibility
pg global temp tables
Oracle-style global temporary tables for PostgreSQL
Stars: ✭ 16 (-81.4%)
Mutual labels:  compatibility
Yapypy
Yet another Python Python
Stars: ✭ 77 (-10.47%)
Mutual labels:  compatibility
Browser Update
Remind users to update their browser in an unobtrusive way
Stars: ✭ 274 (+218.6%)
Mutual labels:  compatibility
Android Scanner Compat Library
A compat library for Bluetooth Low Energy scanning on Android.
Stars: ✭ 462 (+437.21%)
Mutual labels:  compatibility
dirname-filename-esm
__dirname and __filename for ES Modules environment
Stars: ✭ 57 (-33.72%)
Mutual labels:  compatibility
warp2
access legacy Python 2 code from within Python 3
Stars: ✭ 13 (-84.88%)
Mutual labels:  compatibility
React Lifecycles Compat
Backwards compatibility polyfill for React class components
Stars: ✭ 457 (+431.4%)
Mutual labels:  compatibility
graphene
Graphene / Graphene-SGX - a library OS for Linux multi-process applications, with Intel SGX support
Stars: ✭ 741 (+761.63%)
Mutual labels:  compatibility
Preact Compat
🙌 React compatibility layer for Preact.
Stars: ✭ 927 (+977.91%)
Mutual labels:  compatibility
node-compat-require
Easily allow your Node program to run in a target node version range to maximize compatibility.
Stars: ✭ 22 (-74.42%)
Mutual labels:  compatibility
Browser Compat Data
This repository contains compatibility data for Web technologies as displayed on MDN
Stars: ✭ 3,710 (+4213.95%)
Mutual labels:  compatibility
Shouldiprefix
A quick overview of what CSS features to prefix
Stars: ✭ 79 (-8.14%)
Mutual labels:  compatibility
Win7fix
Cube World Beta Compatibility DLLs for Win7_64
Stars: ✭ 26 (-69.77%)
Mutual labels:  compatibility
Dxwrapper
Fixes compatibility issues with older games running on Windows 10 by wrapping DirectX dlls. Also allows loading custom libraries with the file extension .asi into game processes.
Stars: ✭ 460 (+434.88%)
Mutual labels:  compatibility

Compat Package for Julia

Build Status Build status

The Compat package is designed to ease interoperability between older and newer versions of the Julia language. In particular, in cases where it is impossible to write code that works with both the latest Julia master branch and older Julia versions, or impossible to write code that doesn't generate a deprecation warning in some Julia version, the Compat package provides a macro that lets you use the latest syntax in a backwards-compatible way.

This is primarily intended for use by other Julia packages, where it is important to maintain cross-version compatibility.

Usage

To use Compat in your Julia package, add it as a dependency of your package using the package manager

pkg> add Compat

and add a version specifier line such as Compat = "2.2, 3" in the [compat]section of the Project.toml file in your package directory. The version in the latter should be the minimum version that supports all needed fatures (see list below), and (if applicable) any newer major versions verified to be compatible. Then, in your package, shortly after the module statement a line like this:

using Compat

and then as needed add

@compat ...compat syntax...

wherever you want to use syntax that differs in the latest Julia master (the development version of Julia). The compat syntax is usually the syntax on Julia master. However, in a few cases where this is not possible, a slightly different syntax might be used. Please check the list below for the specific syntax you need.

Compatibility

Features in the development versions of julia may be added and released in Compat.jl. However, such features are considered experimental until the relevant julia version is released. These features can be changed or removed without incrementing the major version of Compat.jl if necessary to match changes in julia.

Supported features

  • cispi(x) for accurately calculating cis(pi * x) (#38449) (since Compat 3.25)

  • startswith(s, r::Regex) and endswith(s, r::Regex) (#29790) (since Compat 3.24)

  • sincospi(x) for calculating the tuple (sinpi(x), cospi(x)) (#35816) (since Compat 3.23)

  • Dates.canonicalize can now take a Period as an input (#37391) (since Compat 3.22)

  • Import renaming is available through the @compat macro, e.g. @compat import LinearAlgebra as LA and @compat import LinearAlgebra: cholesky as c, lu as l. Note: Import renaming of macros is not supported due to differences in parsing behavior (#37396). (since Compat 3.21).

  • Compat.parseatom(text::AbstractString, pos::Integer; filename="none") parses a single atom from text starting at index pos. Returns a Tuple consisting of the parsed expression and the index to resume parsing from. (#35243) (since Compat 3.20)

  • Compat.parseall(text::AbstractString; filename="none") parses the whole string text and returns the parsed expression. (#35243) (since Compat 3.20)

  • mul!(C, A, B, alpha, beta) now performs in-place multiply add (#29634). (since Compat 3.19).

  • reinterpret(reshape, T, a::AbstractArray{S}) reinterprets a to have eltype T while inserting or consuming the first dimension depending on the ratio of sizeof(T) and sizeof(S). (#37559). (since Compat 3.18)

  • The composition operator now returns a Compat.ComposedFunction instead of an anonymous function (#37517). (since Compat 3.17)

  • New function addenv for adding environment mappings into a Cmd object, returning the new Cmd object (#37244). (since Compat 3.16)

  • contains(haystack, needle) and its one argument partially applied form contains(haystack) have been added, it acts like occursin(needle, haystack) (#35132). (since Compat 3.15)

  • startswith(x) and endswith(x), returning partially-applied versions of the functions, similar to existing methods like isequal(x) (#35052). (since Compat 3.15)

  • Compat.Iterators.map is added. It provides another syntax Iterators.map(f, iterators...) for writing (f(args...) for args in zip(iterators...)), i.e. a lazy map (#34352). (since Compat 3.14)

  • takewhle and dropwhile are added in Compat.Iterators (#33437). (since Compat 3.14)

  • Curried comparisons !=(x), >=(x), <=(x), >(x), and <(x) are defined as, e.g., !=(x) = y -> y != x (#30915). (since Compat 3.14)

  • strides is defined for Adjoint and Transpose (#35929). (since Compat 3.14)

  • Compat.get_num_threads() adds the functionality of LinearAlgebra.BLAS.get_num_threads(), and has matching Compat.set_num_threads(n) (#36360). (since Compat 3.13.0)

  • @inferred [AllowedType] f(x) is defined (#27516). (since Compat 3.12.0)

  • Search a character in a string with findfirst, findnext, findlast and findprev (#31664). (since Compat 3.12.0)

  • ∘(f) = f is defined (#34251). (since Compat 3.11.0)

  • union supports Base.OneTo (#35577). (since Compat 3.11.0)

  • get supports CartesianIndex when indexing AbstractArrays (#30268). (since Compat 3.10.0)

  • similar(::PermutedDimsArray) now uses the parent (#35304). (since Compat 3.9.0)

  • isdisjoint(l, r) indicates whether two collections are disjoint (#34427). (since Compat 3.9.0)

  • mergewith(combine, dicts...) and mergewith!(combine, dicts...) are like merge(combine, dicts...) and merge!(combine, dicts...) but without the restriction that the argument combine must be a Function (#34296). (since Compat 3.9.0).

  • @NamedTuple macro for convenient struct-like syntax for declaring NamedTuple types via key::Type declarations (#34548). (since Compat 3.8.0)

  • evalpoly(x, (p1, p2, ...)), the function equivalent to @evalpoly(x, p1, p2, ...) (#32753). (since Compat 3.7.0)

  • zero(::Irrational) and one now defined (#34773). (since Compat 3.6.0)

  • I1:I2, when I1 and I2 are CartesianIndex values, constructs a CartesianIndices iterator (#29440). (Since Compat 3.5.0)

  • oneunit(::CartesianIndex) replaces one(::CartesianIndex) (#29442). (Since Compat 3.5.0)

  • ismutable return true iff value v is mutable (#34652). (since Compat 3.4.0)

  • uuid5 generates a version 5 universally unique identifier (UUID), as specified by RFC 4122 (#28761). (since Compat 3.3.0)

  • dot now has a 3-argument method dot(x, A, y) without storing the intermediate result A*y (#32739). (since Compat 3.2.0)

  • pkgdir(m) returns the root directory of the package that imported module m (#33128). (since Compat 3.2.0)

  • filter can now act on a Tuple #32968. (since Compat 3.1.0)

  • Base.Order.ReverseOrdering has a zero arg constructor #33736. (since Compat 3.0.0)

  • Function composition now supports multiple functions: ∘(f, g, h) = f ∘ g ∘ h and splatting ∘(fs...) for composing an iterable collection of functions (#33568). (since Compat 3.0.0)

  • only(x) returns the one-and-only element of a collection x (#33129). (since Compat 2.2.0)

  • mod now accepts a unit range as the second argument (#32628). (since Compat 2.2.0)

  • eachrow, eachcol, and eachslice to iterate over first, second, or given dimension of an array (#29749). (since Compat 2.2.0)

  • isnothing for testing if a variable is equal to nothing (#29674). (since Compat 2.1.0)

  • hasproperty and hasfield (#28850). (since Compat 2.0.0)

  • merge methods with one and n NamedTuples (#29259). (since Compat 2.0.0)

  • range supporting stop as positional argument (#28708). (since Compat 1.3.0)

Developer tips

One of the most important rules for Compat.jl is to avoid breaking user code whenever possible, especially on a released version.

Although the syntax used in the most recent Julia version is the preferred compat syntax, there are cases where this shouldn't be used. Examples include when the new syntax already has a different meaning on previous versions of Julia, or when functions are removed from Base Julia and the alternative cannot be easily implemented on previous versions. In such cases, possible solutions are forcing the new feature to be used with qualified name in Compat.jl (e.g. use Compat.<name>) or reimplementing the old features on a later Julia version.

If you're adding additional compatibility code to this package, the contrib/commit-name.sh script in the base Julia repository is useful for extracting the version number from a git commit SHA. For example, from the git repository of julia, run something like this:

bash $ contrib/commit-name.sh a378b60fe483130d0d30206deb8ba662e93944da
0.5.0-dev+2023

This prints a version number corresponding to the specified commit of the form X.Y.Z-aaa+NNNN, and you can then test whether Julia is at least this version by VERSION >= v"X.Y.Z-aaa+NNNN".

Tagging the correct minimum version of Compat

Note that you should specify the correct minimum version for Compat in the [compat] section of your Project.toml, as given in above list.

Note that the project description data, including the texts, logos, images, and/or trademarks, for each open source project belongs to its rightful owner. If you wish to add or remove any projects, please contact us at [email protected].