Addition of Unicode counterparts of some common operators.

base/exports.jl

@@ -166,7 +166,10 @@ export
     ≠,
     !==,
     ≡,
+    ⩶,
     ≢,
+    !⩵,
+    !⩶,
     xor,
     ⊻,
     nand,
@@ -179,18 +182,26 @@ export
     *,
     +,
     -,
+    −,
     /,
     //,
     <,
+    ≮,
     <:,
     <<,
     <=,
     ≤,
+    ⩽,
+    ≰,
     ==,
+    ⩵,
     >,
+    ≯,
     >:,
     >=,
     ≥,
+    ⩾,
+    ≱,
     >>,
     >>>,
     \,

base/operators.jl

@@ -54,6 +54,7 @@ end
 
 """
     ==(x, y)
+    ⩵(x, y)
 
 Generic equality operator. Falls back to [`===`](@ref).
 Should be implemented for all types with a notion of equality, based on the abstract value
@@ -84,6 +85,7 @@ If some type defines `==`, [`isequal`](@ref), and [`isless`](@ref) then it shoul
 also implement [`<`](@ref) to ensure consistency of comparisons.
 """
 ==
+const ⩵ = ==
 
 """
     isequal(x, y)
@@ -258,7 +260,7 @@ end
 
 """
     !=(x, y)
-    ≠(x,y)
+    ≠(x, y)
 
 Not-equals comparison operator. Always gives the opposite answer as [`==`](@ref).
 
@@ -279,8 +281,9 @@ false
 const ≠ = !=
 
 """
-    ===(x,y) -> Bool
-    ≡(x,y) -> Bool
+    ===(x, y) -> Bool
+    ≡(x, y) -> Bool
+    ⩶(x, y) -> Bool
 
 Determine whether `x` and `y` are identical, in the sense that no program could distinguish
 them. First the types of `x` and `y` are compared. If those are identical, mutable objects
@@ -304,10 +307,13 @@ true
 """
 ===
 const ≡ = ===
+const ⩶ = ===
 
 """
     !==(x, y)
-    ≢(x,y)
+    !⩵(x, y)
+    !⩶(x, y)
+    ≢(x, y)
 
 Always gives the opposite answer as [`===`](@ref).
 
@@ -323,6 +329,8 @@ false
 ```
 """
 !==(@nospecialize(x), @nospecialize(y)) = !(x === y)
+!⩵(@nospecialize(x), @nospecialize(y)) = !(x === y)
+!⩶(@nospecialize(x), @nospecialize(y)) = !(x === y)
 const ≢ = !==
 
 """
@@ -350,6 +358,7 @@ false
 ```
 """
 <(x, y) = isless(x, y)
+≮(x, y) = !<(x, y)
 
 """
     >(x, y)
@@ -376,10 +385,12 @@ true
 ```
 """
 >(x, y) = y < x
+≯(x, y) = !>(x, y)
 
 """
     <=(x, y)
-    ≤(x,y)
+    ≤(x, y)
+    ⩽(x, y)
 
 Less-than-or-equals comparison operator. Falls back to `(x < y) | (x == y)`.
 
@@ -400,10 +411,13 @@ false
 """
 <=(x, y) = (x < y) | (x == y)
 const ≤ = <=
+const ⩽ = ≤
+≰(x, y) = !≤(x, y)
 
 """
     >=(x, y)
-    ≥(x,y)
+    ≥(x, y)
+    ⩾(x, y)
 
 Greater-than-or-equals comparison operator. Falls back to `y <= x`.
 
@@ -424,6 +438,8 @@ true
 """
 >=(x, y) = (y <= x)
 const ≥ = >=
+const ⩾ = ≥
+≱(x, y) = !≥(x, y)
 
 # this definition allows Number types to implement < instead of isless,
 # which is more idiomatic:
@@ -595,6 +611,7 @@ identity(x) = x
 (|)(x::Integer) = x
 xor(x::Integer) = x
 
+const − = -
 const ⊻ = xor
 const ⊼ = nand
 const ⊽ = nor
@@ -1209,6 +1226,19 @@ used to implement specialized methods.
 """
 >=(x) = Fix2(>=, x)
 
+"""
+    ≱(x)
+
+Create a function that compares its argument to `x` using [`≱`](@ref), i.e.
+a function equivalent to `y -> y ≱ x`.
+The returned function is of type `Base.Fix2{typeof(≱)}`, which can be
+used to implement specialized methods.
+
+!!! compat "Julia 1.2"
+    This functionality requires at least Julia 1.2.
+"""
+≱(x) = Fix2(≱, x)
+
 """
     <=(x)
 
@@ -1222,6 +1252,19 @@ used to implement specialized methods.
 """
 <=(x) = Fix2(<=, x)
 
+"""
+    ≰(x)
+
+Create a function that compares its argument to `x` using [`≰`](@ref), i.e.
+a function equivalent to `y -> y ≰ x`.
+The returned function is of type `Base.Fix2{typeof(≰)}`, which can be
+used to implement specialized methods.
+
+!!! compat "Julia 1.2"
+    This functionality requires at least Julia 1.2.
+"""
+≰(x) = Fix2(≰, x)
+
 """
     >(x)
 
@@ -1235,6 +1278,19 @@ used to implement specialized methods.
 """
 >(x) = Fix2(>, x)
 
+"""
+    ≯(x)
+
+Create a function that compares its argument to `x` using [`≯`](@ref), i.e.
+a function equivalent to `y -> y ≯ x`.
+The returned function is of type `Base.Fix2{typeof(≯)}`, which can be
+used to implement specialized methods.
+
+!!! compat "Julia 1.2"
+    This functionality requires at least Julia 1.2.
+"""
+≯(x) = Fix2(≯, x)
+
 """
     <(x)
 
@@ -1248,6 +1304,19 @@ used to implement specialized methods.
 """
 <(x) = Fix2(<, x)
 
+"""
+    ≮(x)
+
+Create a function that compares its argument to `x` using [`≮`](@ref), i.e.
+a function equivalent to `y -> y ≮ x`.
+The returned function is of type `Base.Fix2{typeof(≮)}`, which can be
+used to implement specialized methods.
+
+!!! compat "Julia 1.2"
+    This functionality requires at least Julia 1.2.
+"""
+≮(x) = Fix2(≮, x)
+
 """
     splat(f)
 

src/julia-parser.scm

@@ -15,7 +15,7 @@
 (define prec-lazy-and    (add-dots '(&&)))
 (define prec-comparison
   (append! '(in isa)
-           (add-dots '(> < >= ≥ <= ≤ == === ≡ != ≠ !== ≢ ∈ ∉ ∋ ∌ ⊆ ⊈ ⊂ ⊄ ⊊ ∝ ∊ ∍ ∥ ∦ ∷ ∺ ∻ ∽ ∾ ≁ ≃ ≂ ≄ ≅ ≆ ≇ ≈ ≉ ≊ ≋ ≌ ≍ ≎ ≐ ≑ ≒ ≓ ≖ ≗ ≘ ≙ ≚ ≛ ≜ ≝ ≞ ≟ ≣ ≦ ≧ ≨ ≩ ≪ ≫ ≬ ≭ ≮ ≯ ≰ ≱ ≲ ≳ ≴ ≵ ≶ ≷ ≸ ≹ ≺ ≻ ≼ ≽ ≾ ≿ ⊀ ⊁ ⊃ ⊅ ⊇ ⊉ ⊋ ⊏ ⊐ ⊑ ⊒ ⊜ ⊩ ⊬ ⊮ ⊰ ⊱ ⊲ ⊳ ⊴ ⊵ ⊶ ⊷ ⋍ ⋐ ⋑ ⋕ ⋖ ⋗ ⋘ ⋙ ⋚ ⋛ ⋜ ⋝ ⋞ ⋟ ⋠ ⋡ ⋢ ⋣ ⋤ ⋥ ⋦ ⋧ ⋨ ⋩ ⋪ ⋫ ⋬ ⋭ ⋲ ⋳ ⋴ ⋵ ⋶ ⋷ ⋸ ⋹ ⋺ ⋻ ⋼ ⋽ ⋾ ⋿ ⟈ ⟉ ⟒ ⦷ ⧀ ⧁ ⧡ ⧣ ⧤ ⧥ ⩦ ⩧ ⩪ ⩫ ⩬ ⩭ ⩮ ⩯ ⩰ ⩱ ⩲ ⩳ ⩵ ⩶ ⩷ ⩸ ⩹ ⩺ ⩻ ⩼ ⩽ ⩾ ⩿ ⪀ ⪁ ⪂ ⪃ ⪄ ⪅ ⪆ ⪇ ⪈ ⪉ ⪊ ⪋ ⪌ ⪍ ⪎ ⪏ ⪐ ⪑ ⪒ ⪓ ⪔ ⪕ ⪖ ⪗ ⪘ ⪙ ⪚ ⪛ ⪜ ⪝ ⪞ ⪟ ⪠ ⪡ ⪢ ⪣ ⪤ ⪥ ⪦ ⪧ ⪨ ⪩ ⪪ ⪫ ⪬ ⪭ ⪮ ⪯ ⪰ ⪱ ⪲ ⪳ ⪴ ⪵ ⪶ ⪷ ⪸ ⪹ ⪺ ⪻ ⪼ ⪽ ⪾ ⪿ ⫀ ⫁ ⫂ ⫃ ⫄ ⫅ ⫆ ⫇ ⫈ ⫉ ⫊ ⫋ ⫌ ⫍ ⫎ ⫏ ⫐ ⫑ ⫒ ⫓ ⫔ ⫕ ⫖ ⫗ ⫘ ⫙ ⫷ ⫸ ⫹ ⫺ ⊢ ⊣ ⟂ ⫪ ⫫ <: >:))))
+           (add-dots '(> < >= ≥ <= ≤ == === ≡ != ≠ !== !⩵ !⩶ ≢ ∈ ∉ ∋ ∌ ⊆ ⊈ ⊂ ⊄ ⊊ ∝ ∊ ∍ ∥ ∦ ∷ ∺ ∻ ∽ ∾ ≁ ≃ ≂ ≄ ≅ ≆ ≇ ≈ ≉ ≊ ≋ ≌ ≍ ≎ ≐ ≑ ≒ ≓ ≖ ≗ ≘ ≙ ≚ ≛ ≜ ≝ ≞ ≟ ≣ ≦ ≧ ≨ ≩ ≪ ≫ ≬ ≭ ≮ ≯ ≰ ≱ ≲ ≳ ≴ ≵ ≶ ≷ ≸ ≹ ≺ ≻ ≼ ≽ ≾ ≿ ⊀ ⊁ ⊃ ⊅ ⊇ ⊉ ⊋ ⊏ ⊐ ⊑ ⊒ ⊜ ⊩ ⊬ ⊮ ⊰ ⊱ ⊲ ⊳ ⊴ ⊵ ⊶ ⊷ ⋍ ⋐ ⋑ ⋕ ⋖ ⋗ ⋘ ⋙ ⋚ ⋛ ⋜ ⋝ ⋞ ⋟ ⋠ ⋡ ⋢ ⋣ ⋤ ⋥ ⋦ ⋧ ⋨ ⋩ ⋪ ⋫ ⋬ ⋭ ⋲ ⋳ ⋴ ⋵ ⋶ ⋷ ⋸ ⋹ ⋺ ⋻ ⋼ ⋽ ⋾ ⋿ ⟈ ⟉ ⟒ ⦷ ⧀ ⧁ ⧡ ⧣ ⧤ ⧥ ⩦ ⩧ ⩪ ⩫ ⩬ ⩭ ⩮ ⩯ ⩰ ⩱ ⩲ ⩳ ⩵ ⩶ ⩷ ⩸ ⩹ ⩺ ⩻ ⩼ ⩽ ⩾ ⩿ ⪀ ⪁ ⪂ ⪃ ⪄ ⪅ ⪆ ⪇ ⪈ ⪉ ⪊ ⪋ ⪌ ⪍ ⪎ ⪏ ⪐ ⪑ ⪒ ⪓ ⪔ ⪕ ⪖ ⪗ ⪘ ⪙ ⪚ ⪛ ⪜ ⪝ ⪞ ⪟ ⪠ ⪡ ⪢ ⪣ ⪤ ⪥ ⪦ ⪧ ⪨ ⪩ ⪪ ⪫ ⪬ ⪭ ⪮ ⪯ ⪰ ⪱ ⪲ ⪳ ⪴ ⪵ ⪶ ⪷ ⪸ ⪹ ⪺ ⪻ ⪼ ⪽ ⪾ ⪿ ⫀ ⫁ ⫂ ⫃ ⫄ ⫅ ⫆ ⫇ ⫈ ⫉ ⫊ ⫋ ⫌ ⫍ ⫎ ⫏ ⫐ ⫑ ⫒ ⫓ ⫔ ⫕ ⫖ ⫗ ⫘ ⫙ ⫷ ⫸ ⫹ ⫺ ⊢ ⊣ ⟂ ⫪ ⫫ <: >:))))
 (define prec-pipe<       '(|.<\|| |<\||))
 (define prec-pipe>       '(|.\|>| |\|>|))
 (define prec-colon       (append! '(: |..|) (add-dots '(… ⁝ ⋮ ⋱ ⋰ ⋯))))