base-unicode-symbols-0.2.2.4/0000755000000000000000000000000011775544351014103 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Setup.hs0000644000000000000000000000005711775544351015541 0ustar0000000000000000import Distribution.Simple main = defaultMain base-unicode-symbols-0.2.2.4/base-unicode-symbols.cabal0000644000000000000000000000427211775544351021120 0ustar0000000000000000name: base-unicode-symbols version: 0.2.2.4 cabal-version: >=1.6 build-type: Simple stability: provisional tested-with: GHC ==6.8.1, GHC ==6.10.1, GHC ==6.12.1, GHC ==6.12.3, GHC ==7.0.1, GHC ==7.0.3, GHC ==7.2.1 author: Roel van Dijk maintainer: Roel van Dijk copyright: 2009–2011 Roel van Dijk license: BSD3 license-file: LICENSE category: homepage: http://haskell.org/haskellwiki/Unicode-symbols bug-reports: https://github.com/roelvandijk/base-unicode-symbols/issues synopsis: Unicode alternatives for common functions and operators description: This package defines new symbols for a number of functions, operators and types in the base package. . All symbols are documented with their actual definition and information regarding their Unicode code point. They should be completely interchangeable with their definitions. . For further Unicode goodness you can enable the @UnicodeSyntax@ language extension \[1\]. This extension enables Unicode characters to be used to stand for certain ASCII character sequences, i.e. → instead of @->@, ∀ instead of @forall@ and many others. . Original idea by Péter Diviánszky. . \[1\] extra-source-files: LICENSE, README.markdown source-repository head type: git location: git://github.com/roelvandijk/base-unicode-symbols.git flag old-base description: Support for base < 3.0.3.1 default: False library if flag(old-base) build-depends: base >= 3.0 && < 3.0.3.1 else build-depends: base >= 3.0.3.1 && < 5 exposed-modules: Control.Category.Unicode exposed-modules: Control.Applicative.Unicode , Control.Arrow.Unicode , Control.Monad.Unicode , Data.Bool.Unicode , Data.Eq.Unicode , Data.Foldable.Unicode , Data.Function.Unicode , Data.List.Unicode , Data.Monoid.Unicode , Data.Ord.Unicode , Prelude.Unicode base-unicode-symbols-0.2.2.4/README.markdown0000644000000000000000000000121211775544351016600 0ustar0000000000000000This package defines new symbols for a number of functions and operators in the base package. All symbols are documented with their actual definition and information regarding their Unicode code point. They should be completely interchangeable with their definitions. For further Unicode goodness you can enable the [UnicodeSyntax](http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#unicode-syntax) language extension. This extension enables Unicode characters to be used to stand for certain ASCII character sequences, i.e. → instead of `->`, ∀ instead of `forall` and many others. Original idea by Péter Diviánszky. base-unicode-symbols-0.2.2.4/LICENSE0000644000000000000000000000275411775544351015120 0ustar0000000000000000Copyright 2009–2011 Roel van Dijk All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * The name of Roel van Dijk and the names of contributors may NOT be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. base-unicode-symbols-0.2.2.4/Prelude/0000755000000000000000000000000011775544351015503 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Prelude/Unicode.hs0000644000000000000000000000420111775544351017422 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax #-} {-| Module : Prelude.Unicode Copyright : 2009–2011 Roel van Dijk License : BSD3 (see the file LICENSE) Maintainer : Roel van Dijk -} module Prelude.Unicode ( (¬), (∧), (∨) , (≡), (≢), (≠) , (≤), (≥), (≮), (≯) , π , (÷), (⋅) , (∘) , (⧺) , (∈), (∉) , (⊥) , ℤ, ℚ ) where ------------------------------------------------------------------------------- -- Imports ------------------------------------------------------------------------------- -- from base: import Data.Ratio ( Ratio ) import Prelude ( Num, Floating, Fractional, Integer , (/), (*), pi, undefined ) -- from base-unicode-symbols: import Data.Bool.Unicode ( (∧), (∨), (¬) ) import Data.Eq.Unicode ( (≡), (≢), (≠) ) import Data.Function.Unicode ( (∘) ) import Data.List.Unicode ( (⧺), (∈), (∉) ) import Data.Ord.Unicode ( (≤), (≥), (≮), (≯) ) ------------------------------------------------------------------------------- -- Fixities ------------------------------------------------------------------------------- infixl 7 ÷ infixl 7 ⋅ ------------------------------------------------------------------------------- -- Symbols ------------------------------------------------------------------------------- {-| π = 'pi' U+03C0, GREEK SMALL LETTER PI -} π ∷ Floating α ⇒ α π = pi {-# INLINE π #-} {-| (÷) = ('/') U+00F7, DIVISION SIGN -} (÷) ∷ Fractional α ⇒ α → α → α (÷) = (/) {-# INLINE (÷) #-} {-| (⋅) = ('*') U+22C5, DOT OPERATOR -} (⋅) ∷ Num α ⇒ α → α → α (⋅) = (*) {-# INLINE (⋅) #-} {-| (⊥) = 'undefined' U+22A5, UP TACK -} (⊥) ∷ α (⊥) = undefined {-# INLINE (⊥) #-} ------------------------------------------------------------------------------- -- Types ------------------------------------------------------------------------------- {-| U+2124, DOUBLE-STRUCK CAPITAL Z -} type ℤ = Integer {-| U+2124, DOUBLE-STRUCK CAPITAL Q -} type ℚ = Ratio ℤ base-unicode-symbols-0.2.2.4/Control/0000755000000000000000000000000011775544351015523 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Control/Applicative/0000755000000000000000000000000011775544351017764 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Control/Applicative/Unicode.hs0000644000000000000000000000223611775544351021711 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax #-} {-| Module : Control.Applicative.Unicode Copyright : 2009–2011 Roel van Dijk License : BSD3 (see the file LICENSE) Maintainer : Roel van Dijk -} module Control.Applicative.Unicode ( (⊛), (∅) ) where ------------------------------------------------------------------------------- -- Imports ------------------------------------------------------------------------------- -- from base: import Control.Applicative ( Applicative, Alternative, (<*>), empty ) ------------------------------------------------------------------------------- -- Fixities ------------------------------------------------------------------------------- infixl 4 ⊛ ------------------------------------------------------------------------------- -- Symbols ------------------------------------------------------------------------------- {-| (⊛) = '<*>' U+229B, CIRCLED ASTERISK OPERATOR -} (⊛) ∷ Applicative f ⇒ f (α → β) → f α → f β (⊛) = (<*>) {-# INLINE (⊛) #-} {-| (∅) = 'empty' U+2205, EMPTY SET -} (∅) ∷ Alternative f ⇒ f α (∅) = empty {-# INLINE (∅) #-} base-unicode-symbols-0.2.2.4/Control/Arrow/0000755000000000000000000000000011775544351016615 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Control/Arrow/Unicode.hs0000644000000000000000000000435511775544351020546 0ustar0000000000000000{-# LANGUAGE CPP, NoImplicitPrelude, UnicodeSyntax, TypeOperators #-} {-| Module : Control.Arrow.Unicode Copyright : 2010—2011 Roel van Dijk License : BSD3 (see the file LICENSE) Maintainer : Roel van Dijk -} module Control.Arrow.Unicode ( (⋙) , (⋘) #if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ > 608 , (⁂) #endif , (⧻) , (⫴) ) where ------------------------------------------------------------------------------- -- Imports ------------------------------------------------------------------------------- -- from base: import Control.Arrow ( Arrow, (***), ArrowChoice, (+++), (|||) ) import Data.Either ( Either ) #if (MIN_VERSION_base(3,0,3)) -- from base-unicode-symbols import Control.Category.Unicode ( (⋙), (⋘) ) #else import Control.Arrow ( (>>>), (<<<) ) #endif ------------------------------------------------------------------------------- -- Fixities ------------------------------------------------------------------------------- #if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ > 608 infixr 3 ⁂ #endif infixr 2 ⧻ infixr 2 ⫴ #if ! (MIN_VERSION_base(3,0,3)) infixr 1 ⋙, ⋘ #endif ------------------------------------------------------------------------------- -- Symbols ------------------------------------------------------------------------------- #if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ > 608 {-| (⁂) = ('***') U+2042, ASTERISM -} (⁂) ∷ Arrow a ⇒ a α β → a α' β' → a (α, α') (β, β') (⁂) = (***) {-# INLINE (⁂) #-} #endif {-| (⧻) = ('+++') U+29FB, TRIPLE PLUS -} (⧻) ∷ ArrowChoice a ⇒ a α β → a α' β' → a (Either α α') (Either β β') (⧻) = (+++) {-# INLINE (⧻) #-} {-| (⫴) = ('|||') U+2AF4, TRIPLE VERTICAL BAR BINARY RELATION -} (⫴) ∷ ArrowChoice a ⇒ a α δ → a β δ → a (Either α β) δ (⫴) = (|||) {-# INLINE (⫴) #-} #if ! (MIN_VERSION_base(3,0,3)) {-| (⋙) = ('>>>') U+22D9, VERY MUCH GREATER-THAN -} (⋙) ∷ Arrow a ⇒ a α β → a β γ → a α γ (⋙) = (>>>) {-# INLINE (⋙) #-} {-| (⋘) = ('<<<') U+22D8, VERY MUCH LESS-THAN -} (⋘) ∷ Arrow a ⇒ a β γ → a α β → a α γ (⋘) = (<<<) {-# INLINE (⋘) #-} #endif base-unicode-symbols-0.2.2.4/Control/Category/0000755000000000000000000000000011775544351017300 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Control/Category/Unicode.hs0000644000000000000000000000251511775544351021225 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax #-} {-| Module : Control.Category.Unicode Copyright : 2009–2011 Roel van Dijk License : BSD3 (see the file LICENSE) Maintainer : Roel van Dijk -} module Control.Category.Unicode ( (∘), (⋙), (⋘) ) where ------------------------------------------------------------------------------- -- Imports ------------------------------------------------------------------------------- -- from base: import Control.Category ( Category, (.), (>>>), (<<<) ) ------------------------------------------------------------------------------- -- Fixities ------------------------------------------------------------------------------- infixr 9 ∘ infixr 1 ⋙, ⋘ ------------------------------------------------------------------------------- -- Symbols ------------------------------------------------------------------------------- {-| (∘) = ('.') U+2218, RING OPERATOR -} (∘) ∷ Category c ⇒ c β γ → c α β → c α γ (∘) = (.) {-# INLINE (∘) #-} {-| (⋙) = ('>>>') U+22D9, VERY MUCH GREATER-THAN -} (⋙) ∷ Category c ⇒ c α β → c β γ → c α γ (⋙) = (>>>) {-# INLINE (⋙) #-} {-| (⋘) = ('<<<') U+22D8, VERY MUCH LESS-THAN -} (⋘) ∷ Category c ⇒ c β γ → c α β → c α γ (⋘) = (<<<) {-# INLINE (⋘) #-} base-unicode-symbols-0.2.2.4/Control/Monad/0000755000000000000000000000000011775544351016561 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Control/Monad/Unicode.hs0000644000000000000000000000256011775544351020506 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax #-} {-| Module : Control.Monad.Unicode Copyright : 2010—2011 Roel van Dijk License : BSD3 (see the file LICENSE) Maintainer : Roel van Dijk -} module Control.Monad.Unicode ( (≫=), (≫), (=≪) ) where ------------------------------------------------------------------------------- -- Imports ------------------------------------------------------------------------------- -- from base: import Control.Monad ( Monad, (>>=), (>>), (=<<) ) ------------------------------------------------------------------------------- -- Fixities ------------------------------------------------------------------------------- infixl 1 ≫= infixl 1 ≫ infixr 1 =≪ ------------------------------------------------------------------------------- -- Symbols ------------------------------------------------------------------------------- {-| (≫=) = ('>>=') (U+226B, MUCH GREATER-THAN) + (U+3D, EQUALS SIGN) -} (≫=) ∷ Monad m ⇒ m α → (α → m β) → m β (≫=) = (>>=) {-# INLINE (≫=) #-} {-| (≫) = ('>>') U+226B, MUCH GREATER-THAN -} (≫) ∷ Monad m ⇒ m α → m β → m β (≫) = (>>) {-# INLINE (≫) #-} {-| (=≪) = ('=<<') (U+3D, EQUALS SIGN) + (U+226A, MUCH LESS-THAN) -} (=≪) ∷ Monad m ⇒ (α → m β) → m α → m β (=≪) = (=<<) {-# INLINE (=≪) #-} base-unicode-symbols-0.2.2.4/Data/0000755000000000000000000000000011775544351014754 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Data/List/0000755000000000000000000000000011775544351015667 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Data/List/Unicode.hs0000644000000000000000000000455211775544351017617 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax #-} {-| Module : Data.List.Unicode Copyright : 2009–2011 Roel van Dijk License : BSD3 (see the file LICENSE) Maintainer : Roel van Dijk -} module Data.List.Unicode ( (⧺) , (∈), (∋), (∉), (∌) , (∪), (∖), (∆), (∩) ) where ------------------------------------------------------------------------------- -- Imports ------------------------------------------------------------------------------- -- from base: import Data.Bool ( Bool ) import Data.Eq ( Eq ) import Data.Function ( flip ) import Data.List ( (++), elem, notElem, union, (\\), intersect ) ------------------------------------------------------------------------------- -- Fixities ------------------------------------------------------------------------------- infix 4 ∈ infix 4 ∋ infix 4 ∉ infix 4 ∌ infixr 5 ⧺ infixl 6 ∪ infixr 6 ∩ infixl 9 ∖ infixl 9 ∆ ------------------------------------------------------------------------------- -- Symbols ------------------------------------------------------------------------------- {-| (⧺) = ('++') U+29FA, DOUBLE PLUS -} (⧺) ∷ [α] → [α] → [α] (⧺) = (++) {-# INLINE (⧺) #-} {-| (∈) = 'elem' U+2208, ELEMENT OF -} (∈) ∷ Eq α ⇒ α → [α] → Bool (∈) = elem {-# INLINE (∈) #-} {-| (∋) = 'flip' (∈) U+220B, CONTAINS AS MEMBER -} (∋) ∷ Eq α ⇒ [α] → α → Bool (∋) = flip (∈) {-# INLINE (∋) #-} {-| (∉) = 'notElem' U+2209, NOT AN ELEMENT OF -} (∉) ∷ Eq α ⇒ α → [α] → Bool (∉) = notElem {-# INLINE (∉) #-} {-| (∌) = 'flip' (∉) U+220C, DOES NOT CONTAIN AS MEMBER -} (∌) ∷ Eq α ⇒ [α] → α → Bool (∌) = flip (∉) {-# INLINE (∌) #-} {-| (∪) = 'union' U+222A, UNION -} (∪) ∷ Eq α ⇒ [α] → [α] → [α] (∪) = union {-# INLINE (∪) #-} {-| (∖) = ('\\') U+2216, SET MINUS -} (∖) ∷ Eq α ⇒ [α] → [α] → [α] (∖) = (\\) {-# INLINE (∖) #-} {-| Symmetric difference a ∆ b = (a ∖ b) ∪ (b ∖ a) U+2206, INCREMENT -} (∆) ∷ Eq α ⇒ [α] → [α] → [α] a ∆ b = (a ∖ b) ∪ (b ∖ a) {-# INLINE (∆) #-} {-| (∩) = 'intersect' U+2229, INTERSECTION -} (∩) ∷ Eq α ⇒ [α] → [α] → [α] (∩) = intersect {-# INLINE (∩) #-} base-unicode-symbols-0.2.2.4/Data/Eq/0000755000000000000000000000000011775544351015321 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Data/Eq/Unicode.hs0000644000000000000000000000240211775544351017241 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax #-} {-| Module : Data.Eq.Unicode Copyright : 2009–2011 Roel van Dijk License : BSD3 (see the file LICENSE) Maintainer : Roel van Dijk -} module Data.Eq.Unicode ( (≡), (≢), (≠) ) where ------------------------------------------------------------------------------- -- Imports ------------------------------------------------------------------------------- -- from base: import Data.Bool ( Bool ) import Data.Eq ( Eq, (==), (/=) ) ------------------------------------------------------------------------------- -- Fixities ------------------------------------------------------------------------------- infix 4 ≡ infix 4 ≢ infix 4 ≠ ------------------------------------------------------------------------------- -- Symbols ------------------------------------------------------------------------------- {-| (≡) = ('==') U+2261, IDENTICAL TO -} (≡) ∷ Eq α ⇒ α → α → Bool (≡) = (==) {-# INLINE (≡) #-} {-| (≢) = ('/=') U+2262, NOT IDENTICAL TO -} (≢) ∷ Eq α ⇒ α → α → Bool (≢) = (/=) {-# INLINE (≢) #-} {-| (≠) = ('/=') U+2260, NOT EQUAL TO -} (≠) ∷ Eq α ⇒ α → α → Bool (≠) = (/=) {-# INLINE (≠) #-} base-unicode-symbols-0.2.2.4/Data/Foldable/0000755000000000000000000000000011775544351016464 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Data/Foldable/Unicode.hs0000644000000000000000000000310511775544351020405 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax #-} {-| Module : Data.Foldable.Unicode Copyright : 2009–2011 Roel van Dijk License : BSD3 (see the file LICENSE) Maintainer : Roel van Dijk -} module Data.Foldable.Unicode where ------------------------------------------------------------------------------- -- Imports ------------------------------------------------------------------------------- -- from base: import Data.Bool ( Bool ) import Data.Eq ( Eq ) import Data.Function ( flip ) import Data.Foldable ( Foldable, elem, notElem ) ------------------------------------------------------------------------------- -- Fixities ------------------------------------------------------------------------------- infix 4 ∈ infix 4 ∋ infix 4 ∉ infix 4 ∌ ------------------------------------------------------------------------------- -- Symbols ------------------------------------------------------------------------------- {-| (∈) = 'elem' U+2208, ELEMENT OF -} (∈) ∷ (Foldable t, Eq α) ⇒ α → t α → Bool (∈) = elem {-# INLINE (∈) #-} {-| (∋) = 'flip' (∈) U+220B, CONTAINS AS MEMBER -} (∋) ∷ (Foldable t, Eq α) ⇒ t α → α → Bool (∋) = flip (∈) {-# INLINE (∋) #-} {-| (∉) = 'notElem' U+2209, NOT AN ELEMENT OF -} (∉) ∷ (Foldable t, Eq α) ⇒ α → t α → Bool (∉) = notElem {-# INLINE (∉) #-} {-| (∌) = 'flip' (∉) U+220C, DOES NOT CONTAIN AS MEMBER -} (∌) ∷ (Foldable t, Eq α) ⇒ t α → α → Bool (∌) = flip (∉) {-# INLINE (∌) #-} base-unicode-symbols-0.2.2.4/Data/Function/0000755000000000000000000000000011775544351016541 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Data/Function/Unicode.hs0000644000000000000000000000173211775544351020466 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax #-} {-| Module : Data.Function.Unicode Copyright : 2009–2011 Roel van Dijk License : BSD3 (see the file LICENSE) Maintainer : Roel van Dijk -} module Data.Function.Unicode ( (∘) ) where ------------------------------------------------------------------------------- -- Imports ------------------------------------------------------------------------------- -- from base: import Data.Function ( (.) ) ------------------------------------------------------------------------------- -- Fixities ------------------------------------------------------------------------------- infixr 9 ∘ ------------------------------------------------------------------------------- -- Symbols ------------------------------------------------------------------------------- {-| (∘) = ('.') U+2218, RING OPERATOR -} (∘) ∷ (β → γ) → (α → β) → (α → γ) (∘) = (.) {-# INLINE (∘) #-} base-unicode-symbols-0.2.2.4/Data/Ord/0000755000000000000000000000000011775544351015500 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Data/Ord/Unicode.hs0000644000000000000000000000265711775544351017434 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax #-} {-| Module : Data.Ord.Unicode Copyright : 2009–2011 Roel van Dijk License : BSD3 (see the file LICENSE) Maintainer : Roel van Dijk -} module Data.Ord.Unicode ( (≤), (≥), (≮), (≯) ) where ------------------------------------------------------------------------------- -- Imports ------------------------------------------------------------------------------- -- from base: import Data.Bool ( Bool ) import Data.Ord ( Ord, (<=), (>=) ) ------------------------------------------------------------------------------- -- Fixities ------------------------------------------------------------------------------- infix 4 ≤ infix 4 ≥ infix 4 ≮ infix 4 ≯ ------------------------------------------------------------------------------- -- Symbols ------------------------------------------------------------------------------- {-| (≤) = ('<=') U+2264, LESS-THAN OR EQUAL TO -} (≤) ∷ Ord α ⇒ α → α → Bool (≤) = (<=) {-# INLINE (≤) #-} {-| (≥) = ('>=') U+2265, GREATER-THAN OR EQUAL TO -} (≥) ∷ Ord α ⇒ α → α → Bool (≥) = (>=) {-# INLINE (≥) #-} {-| (≮) = ('>=') U+226E, NOT LESS-THAN -} (≮) ∷ Ord α ⇒ α → α → Bool (≮) = (>=) {-# INLINE (≮) #-} {-| (≯) = ('<=') U+226F, NOT GREATER-THAN -} (≯) ∷ Ord α ⇒ α → α → Bool (≯) = (<=) {-# INLINE (≯) #-} base-unicode-symbols-0.2.2.4/Data/Monoid/0000755000000000000000000000000011775544351016201 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Data/Monoid/Unicode.hs0000644000000000000000000000213111775544351020120 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax #-} {-| Module : Data.Monoid.Unicode Copyright : 2009–2011 Roel van Dijk License : BSD3 (see the file LICENSE) Maintainer : Roel van Dijk -} module Data.Monoid.Unicode ( (∅), (⊕) ) where ------------------------------------------------------------------------------- -- Imports ------------------------------------------------------------------------------- -- from base: import Data.Monoid ( Monoid, mempty, mappend ) ------------------------------------------------------------------------------- -- Fixities ------------------------------------------------------------------------------- infixr 6 ⊕ ------------------------------------------------------------------------------- -- Symbols ------------------------------------------------------------------------------- {-| (∅) = 'mempty' U+2205, EMPTY SET -} (∅) ∷ Monoid α ⇒ α (∅) = mempty {-# INLINE (∅) #-} {-| (⊕) = 'mappend' U+2295, CIRCLED PLUS -} (⊕) ∷ Monoid α ⇒ α → α → α (⊕) = mappend {-# INLINE (⊕) #-} base-unicode-symbols-0.2.2.4/Data/Bool/0000755000000000000000000000000011775544351015647 5ustar0000000000000000base-unicode-symbols-0.2.2.4/Data/Bool/Unicode.hs0000644000000000000000000000227311775544351017575 0ustar0000000000000000{-# LANGUAGE NoImplicitPrelude, UnicodeSyntax #-} {-| Module : Data.Bool.Unicode Copyright : 2009–2011 Roel van Dijk License : BSD3 (see the file LICENSE) Maintainer : Roel van Dijk -} module Data.Bool.Unicode ( (∧), (∨), (¬) ) where ------------------------------------------------------------------------------- -- Imports ------------------------------------------------------------------------------- -- from base: import Data.Bool ( Bool, (&&), (||), not ) ------------------------------------------------------------------------------- -- Fixities ------------------------------------------------------------------------------- infixr 2 ∨ infixr 3 ∧ ------------------------------------------------------------------------------- -- Symbols ------------------------------------------------------------------------------- {-| (¬) = 'not' U+00AC, NOT SIGN -} (¬) ∷ Bool → Bool (¬) = not {-# INLINE (¬) #-} {-| (∧) = ('&&') U+2227, LOGICAL AND -} (∧) ∷ Bool → Bool → Bool (∧) = (&&) {-# INLINE (∧) #-} {-| (∨) = ('||') U+2228, LOGICAL OR -} (∨) ∷ Bool → Bool → Bool (∨) = (||) {-# INLINE (∨) #-}