Module frege.Prelude

Public interface for the various prelude modules

Imports

• import Control.Category as Category
• import Java.IO as IO
• import Java.Lang as Lang
• import Prelude.Maybe as Maybe
• import Prelude.PreludeArrays as PreludeArrays
• import Prelude.PreludeBase as PreludeBase
• import Prelude.PreludeDecimal as PreludeDecimal
• import Prelude.PreludeIO as PreludeIO
• import Prelude.PreludeList as PreludeList
• import Prelude.PreludeMonad as PreludeMonad
• import Prelude.PreludeText as PreludeText
• import Java.util.Regex as Regexp
• import Control.Semigroupoid as Semigroupoid
• import Java.Util as Util

Table of Content

• Definitions

  parseDecimal ∷ String → (NumberFormatException | Decimal)

  print ∷ Show 𝖆 ⇒ 𝖆 → IO ()

  println ∷ Show 𝖆 ⇒ 𝖆 → IO ()

  putChar ∷ Char → IO ()

  putStr ∷ String → IO ()

  putStrLn ∷ String → IO ()

  getChar ∷ IO Char

  getLine ∷ IO String

  getContents ∷ IO String

  getContentsOf ∷ MutableIO Reader → IO String

  interact ∷ (String→String) → IO ()

  readFile ∷ String → IO String

  writeFile ∷ String → String → IO ()

  appendFile ∷ String → String → IO ()

  trace ∷ String → Bool

  traceLn ∷ String → Bool

• Re-Exported Items

  data ()

  data (a, b)

  data (a, b, c)

  data (a, b, c, d)

  data (a, b, c, d, e)

  data (a, b, c, d, e, f)

  data (a, b, c, d, e, f, g)

  data (a, b, c, d, e, f, g, h)

  data (a, b, c, d, e, f, g, h, i)

  data (a, b, c, d, e, f, g, h, i, j)

  data (a, b, c, d, e, f, g, h, i, j, k)

  data (a, b, c, d, e, f, g, h, i, j, k, l)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y)

  data (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)

  data a→b

  class Functor f ⇒ Alt f

  data Appendable = native java.lang.Appendable

  class (Functor p, Apply p) ⇒ Applicative p

  instance Applicative (-> a)

  instance Applicative Maybe

  class Functor f ⇒ Apply f

  class JavaType a ⇒ ArrayElement a

  instance ArrayElement (a, b)

  instance ArrayElement (a, b, c)

  instance ArrayElement (a→b)

  instance ArrayElement Integer

  instance ArrayElement Object

  instance ArrayElement String

  instance ArrayElement [a]

  type ArrayOf s a = Mutable s (JArray a)

  class (Functor f, Apply f) ⇒ Bind f

  data Bool = pure native boolean

  data Boolean = pure native java.lang.Boolean

  class Bounded b

  instance Bounded Bool

  instance Bounded Byte

  instance Bounded Char

  instance Bounded Int

  instance Bounded Long

  instance Bounded Short

  data BufferedReader = native java.io.BufferedReader

  data Byte = pure native byte

  type CatchAll = Either Throwable

  data Char = pure native char

  data CharSequence = pure native java.lang.CharSequence

  data Character = pure native java.lang.Character

  data Class a = pure native java.lang.Class

  data ClassLoader = native java.lang.ClassLoader

  data ClassNotFoundException = pure native java.lang.ClassNotFoundException

  class Freezable f ⇒ Cloneable f

  data Closeable = native java.io.Closeable

  data Comparable t = pure native java.lang.Comparable

  data Decimal = pure native long

  data Double = pure native double

  data EOFException = pure native java.io.EOFException

  data (a | b)

  class (Eq e, Ord e) ⇒ Enum e

  instance Enum Bool

  instance Enum Byte

  instance Enum Char

  instance Enum Int

  instance Enum Integer

  instance Enum Long

  instance Enum Short

  class Eq e

  instance Eq ()

  instance Eq Bool

  instance Eq Byte

  instance Eq Char

  instance Eq Double

  instance Eq Float

  instance Eq Int

  instance Eq a ⇒ Eq (JArray a)

  instance Eq Long

  instance Eq a ⇒ Eq (Maybe a)

  instance Eq Short

  instance Eq String

  instance Eq a ⇒ Eq [a]

  data Error = pure native java.lang.Error

  data Exception = pure native java.lang.Exception

  data ExceptionInInitializerError = pure native java.lang.ExceptionInInitializerError

  class JavaType e ⇒ Exceptional e

  instance Exceptional ClassNotFoundException

  instance Exceptional EOFException

  instance Exceptional Error

  instance Exceptional Exception

  instance Exceptional ExceptionInInitializerError

  instance Exceptional FileNotFoundException

  instance Exceptional GuardFailed

  instance Exceptional IOException

  instance Exceptional IllegalAccessException

  instance Exceptional IllegalArgumentException

  instance Exceptional IllegalStateException

  instance Exceptional IllegalThreadStateException

  instance Exceptional IndexOutOfBoundsException

  instance Exceptional InstantiationException

  instance Exceptional InterruptedException

  instance Exceptional NoMatch

  instance Exceptional NoSuchFieldException

  instance Exceptional NoSuchMethodError

  instance Exceptional NullPointerException

  instance Exceptional PatternSyntaxException

  instance Exceptional SecurityException

  instance Exceptional StringIndexOutOfBoundsException

  instance Exceptional Throwable

  instance Exceptional Undefined

  instance Exceptional UnsupportedEncodingException

  data File = native java.io.File

  data FileInputStream = native java.io.FileInputStream

  data FileNotFoundException = pure native java.io.FileNotFoundException

  data FileOutputStream = native java.io.FileOutputStream

  data Float = pure native float

  data Flushable = native java.io.Flushable

  class Freezable f

  class Functor f

  instance Functor (a)

  instance Functor (a, b)

  instance Functor Maybe

  instance Functor []

  data GuardFailed = pure native frege.runtime.GuardFailed

  data HaskellBool

  type IO = ST RealWorld

  data IOException = pure native java.io.IOException

  type IOMutable d = ST RealWorld (Mutable RealWorld d)

  type IORef a = Mutable RealWorld (Ref a)

  data IllegalAccessException = pure native java.lang.IllegalAccessException

  data IllegalArgumentException = pure native java.lang.IllegalArgumentException

  data IllegalStateException = pure native java.lang.IllegalStateException

  data IllegalThreadStateException = pure native java.lang.IllegalThreadStateException

  data IndexOutOfBoundsException = pure native java.lang.IndexOutOfBoundsException

  data InputStream = native java.io.InputStream

  data InputStreamReader = native java.io.InputStreamReader

  data InstantiationException = pure native java.lang.InstantiationException

  data Int = pure native int

  data Integer = pure native java.math.BigInteger

  class (Eq i, Ord i, Num i) ⇒ Integral i

  instance Integral Byte

  instance Integral Int

  instance Integral Integer

  instance Integral Long

  instance Integral Short

  data InterruptedException = pure native java.lang.InterruptedException

  data Iterable t = pure native java.lang.Iterable

  data JArray a = native java.lang.Object

  data JEnum e = pure native java.lang.Enum

  class JavaType e

  instance JavaType (JArray Int)

  class ListEmpty α

  instance ListEmpty Maybe

  class (ListSemigroup α, ListEmpty α) ⇒ ListMonoid α

  instance ListMonoid StringJ

  instance ListMonoid []

  class ListSemigroup α

  class ListSource α

  instance ListSource (Either α)

  instance ListSource JArray

  instance ListSource Maybe

  instance ListSource []

  class (ListSource c, ListEmpty c) ⇒ ListView c

  instance ListView StringJ

  instance ListView []

  data Long = pure native long

  data MatchResult = pure native java.util.regex.MatchResult

  data Maybe a

  class (Functor m, Apply m, Bind m, Applicative m) ⇒ Monad m

  class (Functor f, Apply f, Bind f, Applicative f, Monad f, Alt f, Plus f) ⇒ MonadAlt f

  class (Functor m, Apply m, Bind m, Applicative m, Monad m) ⇒ MonadFail m

  instance MonadFail (Either String)

  instance MonadFail Maybe

  instance MonadFail (ST s)

  instance MonadFail []

  class (Functor mo, Apply mo, Bind mo, Applicative mo, Monad mo, MonadZero mo) ⇒ MonadOr mo

  class (Functor mp, Apply mp, Bind mp, Applicative mp, Monad mp, MonadZero mp) ⇒ MonadPlus mp

  instance MonadPlus Maybe

  instance MonadPlus []

  class (Functor mz, Apply mz, Bind mz, Applicative mz, Monad mz) ⇒ MonadZero mz

  instance Monad (-> a)

  instance Monad (Either a)

  instance Monad Maybe

  instance Monad (ST s)

  instance Monad []

  data Mutable s m

  type MutableIO = Mutable RealWorld

  data NoMatch = pure native frege.runtime.NoMatch

  data NoSuchFieldException = pure native java.lang.NoSuchFieldException

  data NoSuchMethodError = pure native java.lang.NoSuchMethodError

  data NullPointerException = pure native java.lang.NullPointerException

  class (Eq n, Ord n) ⇒ Num n

  instance Num Byte

  instance Num Int

  instance Num Long

  instance Num Short

  data NumberFormatException = pure native java.lang.NumberFormatException

  data Object = pure native java.lang.Object

  class Eq o ⇒ Ord o

  instance Ord Bool

  instance Ord Byte

  instance Ord Char

  instance Ord Double

  instance Ord Float

  instance Ord Int

  instance Ord Integer

  instance Ord Long

  instance Ord a ⇒ Ord (Maybe a)

  instance Ord Short

  instance Ord String

  instance Ord a ⇒ Ord [a]

  data Ordering

  data OutputStream = native java.io.OutputStream

  data OutputStreamWriter = native java.io.OutputStreamWriter

  class (Functor f, Alt f) ⇒ Plus f

  class (JavaType a, ArrayElement a) ⇒ PrimitiveArrayElement a

  instance PrimitiveArrayElement Bool

  instance PrimitiveArrayElement Byte

  instance PrimitiveArrayElement Char

  instance PrimitiveArrayElement Double

  instance PrimitiveArrayElement Float

  instance PrimitiveArrayElement Int

  instance PrimitiveArrayElement Long

  instance PrimitiveArrayElement Short

  data PrintStream = native java.io.PrintStream

  data PrintWriter = native java.io.PrintWriter

  class Read a

  type ReadS a = StringJ Char → [(a, StringJ Char)]

  instance Read Int

  data Readable = native java.lang.Readable

  data Reader = native java.io.Reader

  class (Eq r, Ord r, Num r) ⇒ Real r

  data RealWorld = pure native frege.runtime.Phantom.RealWorld

  instance Real Double

  instance Real Float

  data Ref a = native frege.runtime.Ref

  data Regex = pure native java.util.regex.Pattern

  instance Replace String

  data Runnable = native java.lang.Runnable

  data ST s a

  type STMutable s d = ST s (Mutable s d)

  data SecurityException = pure native java.lang.SecurityException

  class Freezable f ⇒ Serializable f

  instance Serializable File

  instance Serializable StringBuffer

  data Short = pure native short

  class Show show

  type ShowS = StringJ Char → StringJ Char

  instance Show ()

  instance (Show a, Show b) ⇒ Show (a, b)

  instance (Show a, Show b, Show c) ⇒ Show (a, b, c)

  instance Show Bool

  instance Show Byte

  instance Show Char

  instance Show Double

  instance (Show a, Show b) ⇒ Show (a | b)

  instance Show File

  instance Show Float

  instance Show Int

  instance Show Integer

  instance Show Long

  instance Show a ⇒ Show (Maybe a)

  instance Show Ordering

  instance Show Regex

  instance Show Short

  instance Show String

  instance Show Throwable

  instance Show a ⇒ Show [a]

  type String = StringJ Char

  data StringBuffer = native java.lang.StringBuffer

  data StringBuilder = native java.lang.StringBuilder

  data StringIndexOutOfBoundsException = pure native java.lang.StringIndexOutOfBoundsException

  data StringWriter = native java.io.StringWriter

  data System = pure native java.lang.System

  data Thread = native java.lang.Thread

  data Throwable = pure native java.lang.Throwable

  data Undefined = pure native frege.runtime.Undefined

  data UnsupportedEncodingException = pure native java.io.UnsupportedEncodingException

  data Writer = native java.io.Writer

  data [a]

  ! ∷ Bool → Bool 

  !! ∷ [𝖆] → Int → 𝖆

  !: ∷ 𝖆 → [𝖆] → [𝖆] 

  != ∷ Eq e ⇒ e → e → Bool 

  !== ∷ a → a → Bool  

  !~ ∷ String → Regex → Bool 

  $ ∷ (𝖇→𝖆) → 𝖇 → 𝖆 

  $! ∷ (𝖇→𝖆) → 𝖇 → 𝖆 

  && ∷ Bool → Bool → Bool  

  * ∷ Num n ⇒ n → n → n 

  *> ∷ Applicative p ⇒ p a → p b → p b 

  + ∷ Num n ⇒ n → n → n 

  ++ ∷ ListSemigroup α ⇒ α β → α β → α β 

  - ∷ Num n ⇒ n → n → n 

  / ∷ Real r ⇒ r → r → r 

  != ∷ Eq e ⇒ e → e → Bool 

  < ∷ Ord o ⇒ o → o → Bool 

  fmap ∷ Functor f ⇒ (a → b) → f a → f b 

  <* ∷ Applicative p ⇒ p a → p b → p a 

  <*> ∷ Apply f ⇒ f (a→b) → f a → f b 

  <+> ∷ MonadAlt f ⇒ f a → f a → f a 

  <= ∷ Ord o ⇒ o → o → Bool 

  <=< ∷ Bind 𝖆 ⇒ (𝖈→𝖆 𝖇) → (𝖉→𝖆 𝖈) → 𝖉 → 𝖆 𝖇 

  <=> ∷ Ord o ⇒ o → o → Ordering 

  <|> ∷ Alt f ⇒ f a → f a → f a 

  =<< ∷ Bind 𝖆 ⇒ (𝖈→𝖆 𝖇) → 𝖆 𝖈 → 𝖆 𝖇 

  == ∷ Eq e ⇒ e → e → Bool 

  === ∷ a → a → Bool  

  =~ ∷ String → Regex → Maybe MatchResult  

  =~~ ∷ String → Regex → [Maybe String] 

  > ∷ Ord o ⇒ o → o → Bool 

  >= ∷ Ord o ⇒ o → o → Bool 

  >=> ∷ Bind 𝖆 ⇒ (𝖈→𝖆 𝖉) → (𝖉→𝖆 𝖇) → 𝖈 → 𝖆 𝖇 

  >> ∷ Monad m ⇒ m a → m b → m b 

  >>= ∷ Bind f ⇒ f a → (a → f b) → f b 

  ? ∷ Int → Int 

  @ ∷ 𝖆 → 𝖇 → () 

  Eq

  Gt

  Lt

  ^ ∷ (Integral i, Num a) ⇒ a → i → a 

  ^^ ∷ Bool → Bool → Bool 

  abs ∷ Num n ⇒ n → n

  all ∷ (𝖆→Bool) → [𝖆] → Bool

  and ∷ [Bool] → Bool

  any ∷ (𝖆→Bool) → [𝖆] → Bool

  ap ∷ Monad α ⇒ α (γ→β) → α γ → α β

  appendWriter ∷ String → STMutable RealWorld PrintWriter

  apply ∷ Apply p ⇒ p (a→b) → p a → p b

  arrayCache ∷ ArrayElement a ⇒ (Int → JArray a → a) → Int → JArray a

  arrayCacheST ∷ ArrayElement a ⇒ (Int → JArray a → a) → Int → STMutable s (JArray a)

  arrayFromIndexList ∷ ArrayElement a ⇒ [(Int, a)] → JArray a

  arrayFromIndexListST ∷ ArrayElement a ⇒ [(Int, a)] → STMutable β (JArray a)

  arrayFromList ∷ ArrayElement a ⇒ [a] → JArray a

  arrayFromListST ∷ ArrayElement a ⇒ [a] → STMutable β (JArray a)

  arrayFromMaybeList ∷ ArrayElement a ⇒ [Maybe a] → JArray a

  arrayFromMaybeListST ∷ ArrayElement a ⇒ [Maybe a] → STMutable β (JArray a)

  arrayLength ∷ ArrayElement a ⇒ JArray a → Int 

  asTypeOf ∷ a → a → a

  comparing ∷ Ord 𝖇 ⇒ (𝖆→𝖇) → 𝖆 → 𝖆 → Ordering

  atoi ∷ String → Int

  bool ∷ 𝖆 → 𝖆 → Bool → 𝖆

  break ∷ (𝖆→Bool) → [𝖆] → ([𝖆], [𝖆])

  byte ∷ Int → Byte 

  catMaybes ∷ ListSource 𝖇 ⇒ 𝖇 (Maybe 𝖆) → [𝖆]

  catch ∷ Exceptional γ ⇒ ST β α → (γ → ST β α) → ST β α 

  catchAll ∷ ST α β → ST α (Exception | β)

  chomp ∷ String → String

  chr ∷ Int → Char

  chunked ∷ Int → [𝖆] → [[𝖆]]

  clone ∷ Cloneable f ⇒ f → f 

  compare ∷ Ord o ⇒ o → o → Ordering 

  comparing ∷ Ord 𝖇 ⇒ (𝖆→𝖇) → 𝖆 → 𝖆 → Ordering

  concat ∷ ListMonoid α ⇒ [α β] → α β

  concatMap ∷ ListMonoid 𝖇 ⇒ (𝖈→𝖇 𝖆) → [𝖈] → 𝖇 𝖆

  const ∷ 𝖇 → 𝖆 → 𝖇

  constructor ∷ a → Int 

  copySerializable ∷ Serializable f ⇒ f → f 

  ctos ∷ Char → String 

  curry ∷ ((𝖇, 𝖈)→𝖆) → 𝖇 → 𝖈 → 𝖆

  cycle ∷ [α] → [α]

  descending ∷ Ord 𝖇 ⇒ (𝖆→𝖇) → 𝖆 → 𝖆 → Ordering

  display ∷ Show show ⇒ show → String

  div ∷ Integral i ⇒ i → i → i 

  divMod ∷ Integral i ⇒ i → i → (i, i)

  drop ∷ ListView c ⇒ Int → c e → c e

  dropWhile ∷ (𝖆→Bool) → [𝖆] → [𝖆]

  either ∷ (𝖇→𝖆) → (𝖈→𝖆) → (𝖇 | 𝖈) → 𝖆 

  elem ∷ Eq 𝖆 ⇒ 𝖆 → [𝖆] → Bool 

  elemAt ∷ ArrayElement a ⇒ JArray a → Int → a 

  empty ∷ ListEmpty α ⇒ α β

  enumFrom ∷ Enum e ⇒ e → [e]

  enumFromThen ∷ Enum e ⇒ e → e → [e]

  enumFromThenTo ∷ Enum e ⇒ e → e → e → [e]

  enumFromTo ∷ Enum e ⇒ e → e → [e]

  error ∷ String → u

  even ∷ Integral i ⇒ i → Bool

  fail ∷ MonadFail m ⇒ String → m a

  filter ∷ (𝖆→Bool) → [𝖆] → [𝖆]

  filterM ∷ (Applicative 𝖆, Bind 𝖆) ⇒ (𝖇→𝖆 Bool) → [𝖇] → 𝖆 [𝖇]

  finally ∷ IO a → IO b → IO a  

  findAt ∷ String → Regex → Int → Maybe MatchResult 

  flip ∷ (𝖇→𝖈→𝖆) → 𝖈 → 𝖇 → 𝖆

  fmap ∷ Functor f ⇒ (a → b) → f a → f b 

  fold ∷ (𝖆→𝖇→𝖆) → 𝖆 → [𝖇] → 𝖆

  foldM ∷ (Applicative 𝖆, Bind 𝖆) ⇒ (𝖇→𝖈→𝖆 𝖇) → 𝖇 → [𝖈] → 𝖆 𝖇

  foldM_ ∷ Monad 𝖆 ⇒ (𝖇→𝖈→𝖆 𝖇) → 𝖇 → [𝖈] → 𝖆 ()

  foldl ∷ (𝖆→𝖇→𝖆) → 𝖆 → [𝖇] → 𝖆

  fold ∷ (𝖆→𝖇→𝖆) → 𝖆 → [𝖇] → 𝖆

  foldl1 ∷ (𝖆→𝖆→𝖆) → [𝖆] → 𝖆

  foldl1 ∷ (𝖆→𝖆→𝖆) → [𝖆] → 𝖆

  foldr ∷ (𝖆→𝖇→𝖇) → 𝖇 → [𝖆] → 𝖇

  foldr1 ∷ (𝖆→𝖆→𝖆) → [𝖆] → 𝖆

  foldrs ∷ (𝖇→𝖆→𝖆) → 𝖆 → [𝖇] → 𝖆

  for ∷ (Monad m, ListSource listSource) ⇒ listSource e → (e → m a) → m ()

  forM ∷ (Applicative 𝖆, Bind 𝖆) ⇒ [𝖈] → (𝖈→𝖆 𝖇) → 𝖆 [𝖇]

  forM_ ∷ Monad 𝖆 ⇒ [𝖈] → (𝖈→𝖆 𝖇) → 𝖆 ()

  forever ∷ Monad 𝖆 ⇒ 𝖆 𝖇 → 𝖆 𝖈

  freeze ∷ Freezable f ⇒ f → f

  from ∷ Enum e ⇒ Int → e

  fromDouble ∷ Real r ⇒ Double → r

  ord ∷ Enum e ⇒ e → Int

  fromInt ∷ Num n ⇒ Int → n

  fromInteger ∷ Num n ⇒ Integer → n

  fromIntegral ∷ (Integral i, Num b) ⇒ i → b

  fromMaybe ∷ 𝖆 → Maybe 𝖆 → 𝖆

  fst ∷ (𝖆, 𝖇) → 𝖆

  gcd ∷ Integral i ⇒ i → i → i

  gcdHelper ∷ Integral i ⇒ i → i → i

  genericArrayFold ∷ (α → β → α) → α → JArray β → α

  genericArrayFromIndexList ∷ JavaType α ⇒ [(Int, α)] → JArray α

  genericArrayMap ∷ (ArrayElement a, ArrayElement β) ⇒ (a → β) → JArray a → JArray β

  genericToMaybeList ∷ JArray α → [Maybe α]

  getAt ∷ ArrayElement a ⇒ ArrayOf s a → Int → ST s (Maybe a) 

  getElemAt ∷ ArrayElement a ⇒ ArrayOf s a → Int → ST s a 

  guard ∷ MonadZero 𝖆 ⇒ Bool → 𝖆 ()

  hashCode ∷ Eq e ⇒ e → Int

  head ∷ ListView c ⇒ c e → e

  id ∷ Category f ⇒ f a a

  init ∷ [𝖆] → [𝖆]

  isInfinite ∷ Num n ⇒ n → Bool

  isJust ∷ Maybe 𝖆 → Bool

  isNaN ∷ Num n ⇒ n → Bool

  isNothing ∷ Maybe 𝖆 → Bool

  isNumber ∷ Num n ⇒ n → Bool

  itemAt ∷ ArrayElement a ⇒ JArray a → Int → Maybe a 

  iterate ∷ (𝖆→𝖆) → 𝖆 → [𝖆]

  javaClass ∷ JavaType e ⇒ Class e

  join ∷ Monad m ⇒ m (m a) → m a

  joined ∷ String → [String] → String

  last ∷ [𝖆] → 𝖆

  lazyif ∷ Bool → 𝖆 → 𝖆 → 𝖆

  lcm ∷ Integral i ⇒ i → i → i

  length ∷ ListView c ⇒ c e → Int

  liftA ∷ Applicative f ⇒ (a → b) → f a → f b

  liftA2 ∷ Applicative f ⇒ (a → b → c) → f a → f b → f c

  liftA3 ∷ Applicative f ⇒ (a → b → c → d) → f a → f b → f c → f d

  liftA4 ∷ Applicative f ⇒ (a → b → c → d → e) → f a → f b → f c → f d → f e

  liftA5 ∷ Applicative f ⇒ (a → b → c → d → e → g) → f a → f b → f c → f d → f e → f g

  liftM ∷ Monad m ⇒ (a → b) → m a → m b

  liftM2 ∷ (Applicative 𝖆, Bind 𝖆) ⇒ (𝖈→𝖉→𝖇) → 𝖆 𝖈 → 𝖆 𝖉 → 𝖆 𝖇

  liftM3 ∷ (Applicative 𝖆, Bind 𝖆) ⇒ (𝖈→𝖉→𝖊→𝖇) → 𝖆 𝖈 → 𝖆 𝖉 → 𝖆 𝖊 → 𝖆 𝖇

  liftM4 ∷ (Applicative 𝖆, Bind 𝖆) ⇒ (𝖈→𝖉→𝖊→𝖋→𝖇) → 𝖆 𝖈 → 𝖆 𝖉 → 𝖆 𝖊 → 𝖆 𝖋 → 𝖆 𝖇

  liftM5 ∷ (Applicative 𝖆, Bind 𝖆) ⇒ (𝖈→𝖉→𝖊→𝖋→𝖌→𝖇) → 𝖆 𝖈 → 𝖆 𝖉 → 𝖆 𝖊 → 𝖆 𝖋 → 𝖆 𝖌 → 𝖆 𝖇

  lineSeparator ∷ String

  lines ∷ String → [String]

  listFromArray ∷ ArrayElement a ⇒ JArray a → [a]

  listToMaybe ∷ ListSource 𝖇 ⇒ 𝖇 𝖆 → Maybe 𝖆

  map ∷ (𝖇→𝖆) → [𝖇] → [𝖆]

  mapAndUnzipM ∷ (Applicative 𝖆, Bind 𝖆) ⇒ (𝖇→𝖆 (𝖈, 𝖉)) → [𝖇] → 𝖆 ([𝖈], [𝖉])

  mapM ∷ (Applicative 𝖆, Bind 𝖆) ⇒ (𝖈→𝖆 𝖇) → [𝖈] → 𝖆 [𝖇]

  mapM_ ∷ Monad 𝖆 ⇒ (𝖈→𝖆 𝖇) → [𝖈] → 𝖆 ()

  mapMaybe ∷ (𝖇→Maybe 𝖆) → [𝖇] → [𝖆]

  mapReader ∷ (a → b) → (r → a) → r → b

  max ∷ Ord o ⇒ o → o → o

  maxBound ∷ Bounded b ⇒ b

  maximum ∷ Ord 𝖆 ⇒ [𝖆] → 𝖆

  maybe ∷ 𝖆 → (𝖇→𝖆) → Maybe 𝖇 → 𝖆

  maybeListFromArray ∷ ArrayElement a ⇒ JArray a → [Maybe a]

  maybeToList ∷ Maybe a → [a]

  min ∷ Ord o ⇒ o → o → o

  minBound ∷ Bounded b ⇒ b

  minimum ∷ Ord 𝖆 ⇒ [𝖆] → 𝖆

  mod ∷ Integral i ⇒ i → i → i 

  modifyAt ∷ ArrayElement a ⇒ (a → a) → ArrayOf s a → Int → ST s ()

  modifyElemAt ∷ ArrayElement a ⇒ (a → a) → ArrayOf s a → Int → ST s ()

  modify ∷ Mutable 𝖇 (Ref 𝖆) → (𝖆→𝖆) → ST 𝖇 ()

  mplus ∷ MonadPlus mp ⇒ mp a → mp a → mp a 

  msum ∷ MonadPlus 𝖇 ⇒ [𝖇 𝖆] → 𝖇 𝖆

  mutable ∷ 𝖇 → Mutable 𝖆 𝖇

  mzero ∷ MonadZero mz ⇒ mz a

  nan ∷ Real r ⇒ r

  negate ∷ Num n ⇒ n → n

  negativeInfinity ∷ Real r ⇒ r

  newArray ∷ ArrayElement a ⇒ Int → STMutable s (JArray a) 

  new ∷ a → STMutable s (Ref a) 

  not ∷ Bool → Bool 

  notElem ∷ Eq 𝖆 ⇒ 𝖆 → [𝖆] → Bool 

  null ∷ ListEmpty α ⇒ α β → Bool

  odd ∷ Integral i ⇒ i → Bool

  oder ∷ Bool → Bool → Bool 

  on ∷ (𝖇→𝖇→𝖆) → (𝖈→𝖇) → 𝖈 → 𝖈 → 𝖆 

  one ∷ Num n ⇒ n

  openReader ∷ String → STMutable RealWorld BufferedReader

  openWriter ∷ String → STMutable RealWorld PrintWriter

  or ∷ [Bool] → Bool

  orElse ∷ MonadOr mo ⇒ mo a → mo a → mo a

  ord ∷ Enum e ⇒ e → Int

  otherwise ∷ Bool

  packed ∷ [Char] → String

  positiveInfinity ∷ Real r ⇒ r

  powf ∷ (Integral i, Num a) ⇒ a → i → a

  powg ∷ (Integral i, Num a) ⇒ a → i → a → a

  pred ∷ Enum e ⇒ e → e

  printStr ∷ String → IO () 

  printStrLn ∷ String → IO () 

  product ∷ Num 𝖆 ⇒ [𝖆] → 𝖆

  pure ∷ Applicative p ⇒ a → p a

  pzero ∷ Plus f ⇒ f a

  quot ∷ Integral i ⇒ i → i → i 

  quotRem ∷ Integral i ⇒ i → i → (i, i)

  read ∷ Read a ⇒ String → a

  get ∷ Mutable s (Ref a) → ST s a 

  readonly ∷ (m → b) → Mutable s m → ST s b

  compile ∷ String → (PatternSyntaxException | Regex) String → Int → (PatternSyntaxException | Regex) 

  regforce ∷ String → Regex String → Int → Regex 

  rem ∷ Integral i ⇒ i → i → i 

  repeat ∷ 𝖆 → [𝖆]

  replicate ∷ Int → 𝖆 → [𝖆]

  replicateM ∷ Monad m ⇒ Int → m a → m [a]

  replicateM_ ∷ Monad m ⇒ Int → m a → m ()

  pure ∷ Applicative p ⇒ a → p a

  reverse ∷ [𝖆] → [𝖆]

  runReader ∷ (r → a) → r → a

  scanl ∷ (𝖇→𝖆→𝖇) → 𝖇 → [𝖆] → [𝖇]

  scanl1 ∷ (𝖆→𝖆→𝖆) → [𝖆] → [𝖆]

  scanr ∷ (α → β → β) → β → [α] → [β]

  scanr1 ∷ (𝖆→𝖆→𝖆) → [𝖆] → [𝖆]

  seq ∷ 𝖆 → 𝖇 → 𝖇 

  sequence ∷ (Applicative 𝖆, Bind 𝖆) ⇒ [𝖆 𝖇] → 𝖆 [𝖇]

  sequence_ ∷ Monad 𝖆 ⇒ [𝖆 𝖇] → 𝖆 ()

  setAt ∷ ArrayElement a ⇒ ArrayOf s a → Int → Maybe a → ST s () 

  setElemAt ∷ ArrayElement a ⇒ ArrayOf s a → Int → a → ST s () 

  short ∷ Int → Short 

  shortFilterM ∷ (Applicative 𝖆, Bind 𝖆) ⇒ (𝖇→𝖆 Bool) → [𝖇] → 𝖆 [𝖇]

  shortFoldM ∷ (Applicative 𝖆, Bind 𝖆) ⇒ (𝖇→𝖈→𝖆 𝖇) → 𝖇 → [𝖈] → 𝖆 𝖇

  shortSequence ∷ (Applicative 𝖆, Bind 𝖆) ⇒ [𝖆 𝖇] → 𝖆 [𝖇]

  show ∷ Show show ⇒ show → String

  showChar ∷ Char → String → String

  showChars ∷ Show show ⇒ show → [Char]

  showList ∷ Show show ⇒ [show] → String → String

  showParen ∷ Bool → (String → String) → String → String

  showString ∷ String → String → String

  shows ∷ Show a ⇒ a → String → String

  showsPrec ∷ Show show ⇒ Int → show → String → String

  showsub ∷ Show show ⇒ show → String

  sign ∷ Num n ⇒ n → Int

  snd ∷ (𝖇, 𝖆) → 𝖆

  span ∷ (𝖆→Bool) → [𝖆] → ([𝖆], [𝖆])

  splitAt ∷ ListView 𝖇 ⇒ Int → 𝖇 𝖆 → (𝖇 𝖆, 𝖇 𝖆)

  splittedWords ∷ String → [String]

  stderr ∷ MutableIO PrintWriter 

  stdin ∷ MutableIO BufferedReader 

  stdout ∷ MutableIO PrintWriter 

  strhead ∷ StringJ 𝖆 → Int → StringJ 𝖆

  strictTuple10 ∷ a → b → c → d → e → f → g → h → i → j → (a, b, c, d, e, f, g, h, i, j) 

  strictTuple11 ∷ a → b → c → d → e → f → g → h → i → j → k → (a, b, c, d, e, f, g, h, i, j, k) 

  strictTuple12 ∷ a → b → c → d → e → f → g → h → i → j → k → l → (a, b, c, d, e, f, g, h, i, j, k, l) 

  strictTuple13 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → (a, b, c, d, e, f, g, h, i, j, k, l, m) 

  strictTuple14 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → (a, b, c, d, e, f, g, h, i, j, k, l, m, n) 

  strictTuple15 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → o → (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) 

  strictTuple16 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → o → p → (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) 

  strictTuple17 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → o → p → q → (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) 

  strictTuple18 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → o → p → q → r → (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) 

  strictTuple19 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → o → p → q → r → s → (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) 

  strictTuple2 ∷ a → b → (a, b) 

  strictTuple20 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → o → p → q → r → s → t → (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) 

  strictTuple21 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → o → p → q → r → s → t → u → (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) 

  strictTuple22 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → o → p → q → r → s → t → u → v → (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) 

  strictTuple23 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → o → p → q → r → s → t → u → v → w → (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) 

  strictTuple24 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → o → p → q → r → s → t → u → v → w → x → (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) 

  strictTuple25 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → o → p → q → r → s → t → u → v → w → x → y → (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) 

  strictTuple26 ∷ a → b → c → d → e → f → g → h → i → j → k → l → m → n → o → p → q → r → s → t → u → v → w → x → y → z → (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) 

  strictTuple3 ∷ a → b → c → (a, b, c) 

  strictTuple4 ∷ a → b → c → d → (a, b, c, d) 

  strictTuple5 ∷ a → b → c → d → e → (a, b, c, d, e) 

  strictTuple6 ∷ a → b → c → d → e → f → (a, b, c, d, e, f) 

  strictTuple7 ∷ a → b → c → d → e → f → g → (a, b, c, d, e, f, g) 

  strictTuple8 ∷ a → b → c → d → e → f → g → h → (a, b, c, d, e, f, g, h) 

  strictTuple9 ∷ a → b → c → d → e → f → g → h → i → (a, b, c, d, e, f, g, h, i) 

  strtail ∷ StringJ a → Int → StringJ a 

  replaceAll ∷ String → Regex → String → String 

  replaceFirst ∷ String → Regex → String → String 

  substr ∷ StringJ a → Int → Int → StringJ a 

  subtract ∷ Num n ⇒ n → n → n

  succ ∷ Enum e ⇒ e → e

  sum ∷ Num 𝖆 ⇒ [𝖆] → 𝖆

  tail ∷ ListView c ⇒ c e → c e

  take ∷ ListView c ⇒ Int → c e → c e

  takeWhile ∷ (𝖆→Bool) → [𝖆] → [𝖆]

  thaw ∷ Freezable f ⇒ f → f

  throw ∷ Throwable → 𝖆

  throwIO ∷ Throwable → IO a

  throwST ∷ Throwable → ST s a

  from ∷ Enum e ⇒ Int → e

  big ∷ Integral i ⇒ i → Integer

  toList ∷ ListSource α ⇒ α β → [β]

  traceStr ∷ String → IO () 

  traceStrLn ∷ String → IO () 

  try ∷ (Applicative 𝖆, Bind 𝖆) ⇒ (𝖈→𝖆 𝖇) → 𝖈 → 𝖆 𝖇

  unJust ∷ Maybe 𝖆 → 𝖆

  uncons ∷ ListView c ⇒ c e → Maybe (e, c e)

  uncurry ∷ (𝖇→𝖈→𝖆) → (𝖇, 𝖈) → 𝖆

  und ∷ Bool → Bool → Bool 

  undefined ∷ u

  unless ∷ Applicative 𝖆 ⇒ Bool → 𝖆 () → 𝖆 ()

  unlines ∷ [String] → String

  unpacked ∷ String → [Char]

  unwords ∷ [String] → String

  unzip ∷ [(𝖆, 𝖇)] → ([𝖆], [𝖇])

  unzip3 ∷ [(𝖆, 𝖇, 𝖈)] → ([𝖆], [𝖇], [𝖈])

  using ∷ Eq 𝖇 ⇒ (𝖆→𝖇) → 𝖆 → 𝖆 → Bool

  void ∷ Functor 𝖆 ⇒ 𝖆 𝖇 → 𝖆 ()

  when ∷ Applicative 𝖆 ⇒ Bool → 𝖆 () → 𝖆 ()

  withReader ∷ (e → r) → (r → a) → e → a

  words ∷ String → [String]

  put ∷ Mutable s (Ref a) → a → ST s () 

  zero ∷ Num n ⇒ n

  zip ∷ [𝖆] → [𝖇] → [(𝖆, 𝖇)]

  zip3 ∷ [𝖆] → [𝖇] → [𝖈] → [(𝖆, 𝖇, 𝖈)]

  zipWith ∷ (𝖇→𝖈→𝖆) → [𝖇] → [𝖈] → [𝖆]

  zipWith3 ∷ (𝖇→𝖈→𝖉→𝖆) → [𝖇] → [𝖈] → [𝖉] → [𝖆]

  zipWithM ∷ (Applicative 𝖆, Bind 𝖆) ⇒ (𝖈→𝖉→𝖆 𝖇) → [𝖈] → [𝖉] → 𝖆 [𝖇]

  zipWithM_ ∷ Monad 𝖆 ⇒ (𝖈→𝖉→𝖆 𝖇) → [𝖈] → [𝖉] → 𝖆 ()

  || ∷ Bool → Bool → Bool  

  ~ ∷ String → Regex → Bool  

  ~~ ∷ String → Regex → Maybe String 

  ~~* ∷ String → Regex → [String] 

  ~~~ ∷ String → Regex → Int → Maybe String 

  • ∷ Semigroupoid f ⇒ f b c → f a b → f a c 

• Instances

  instance (Bounded a, Bounded b) ⇒ Bounded (a, b)

  instance (Bounded a, Bounded b, Bounded c) ⇒ Bounded (a, b, c)

  instance Enum Ordering

  instance (Eq a, Eq b) ⇒ Eq (a, b)

  instance (Eq a, Eq b, Eq c) ⇒ Eq (a, b, c)

  instance (Eq a, Eq b) ⇒ Eq (a | b)

  instance Eq Ordering

  instance Ord ()

  instance (Ord a, Ord b) ⇒ Ord (a, b)

  instance (Ord a, Ord b, Ord c) ⇒ Ord (a, b, c)

  instance (Ord a, Ord b) ⇒ Ord (a | b)

  instance Ord Ordering

  instance Show Decimal

• Functions and Values by Type

Definitions

parseDecimal ∷ String → (NumberFormatException | Decimal)

for now

print ∷ Show 𝖆 ⇒ 𝖆 → IO ()

Print a value to the standard output writer.

This will come out UTF8 encoded.

println ∷ Show 𝖆 ⇒ 𝖆 → IO ()

Print a value to the standard output stream and append a platform typical new line character.

This will come out UTF8 encoded.

putChar ∷ Char → IO ()

write a character to IO.stdout

putStr ∷ String → IO ()

write a String to standard output (Haskell compatibility)

putStrLn ∷ String → IO ()

write a String and a new line to standard output (Haskell compatibility)

getChar ∷ IO Char

read a character from the standard input reader

getLine ∷ IO String

read a line from the standard input reader, end of line characters are removed.

getContents ∷ IO String

The getContents operation returns all user input as a single string

getContentsOf ∷ MutableIO Reader → IO String

The getContentsOf operation returns all input from the supplied Reader as a single string.

After completion, the Reader is closed.

interact ∷ (String→String) → IO ()

The interact function takes a function of type String -> String as its argument. The entire input from the standard input device is passed to this function as its argument, and the resulting string is output on the standard output device.

readFile ∷ String → IO String

The readFile function reads a file and returns the contents of the file as a string.

If the file doesn't exist, a FileNotFoundException will be thrown.

writeFile ∷ String → String → IO ()

Writes the String given as second argument to the file whose name is given as the first argument.

After completion, the file will be closed.

appendFile ∷ String → String → IO ()

Appends the String given as second argument to the file whose name is given as the first argument.

After completion, the file will be closed.

trace ∷ String → Bool

nowarn: performUnsafe

unsafe trace, returns always false and can thus be used like

 fun x y
    | trace   ("x is " ++ show x) = undefined
    | traceLn ("y is " ++ show y) = undefined
    | otherwise = ......

Note that this imposes strictness on the traced data.

traceLn ∷ String → Bool

nowarn: performUnsafe

same as trace but appends a line break

Instances

instance (Bounded a, Bounded b) ⇒ Bounded (a, b)

Member Functions

maxBound ∷ (Bounded 𝖇, Bounded 𝖆) ⇒ (𝖇, 𝖆)

minBound ∷ (Bounded 𝖇, Bounded 𝖆) ⇒ (𝖇, 𝖆)

instance (Bounded a, Bounded b, Bounded c) ⇒ Bounded (a, b, c)

Member Functions

maxBound ∷ (Bounded 𝖇, Bounded 𝖈, Bounded 𝖆) ⇒ (𝖇, 𝖈, 𝖆)

minBound ∷ (Bounded 𝖇, Bounded 𝖈, Bounded 𝖆) ⇒ (𝖇, 𝖈, 𝖆)

instance Enum Ordering

Member Functions

enumFrom ∷ Ordering → [Ordering]

inherited from Enum.enumFrom

enumFromThen ∷ Ordering → Ordering → [Ordering]

Function generated for derived instance.

enumFromThenTo ∷ Ordering → Ordering → Ordering → [Ordering]

Function generated for derived instance.

enumFromTo ∷ Ordering → Ordering → [Ordering]

inherited from Enum.enumFromTo

from ∷ Int → Ordering

Function generated for derived instance.

ord ∷ Ordering → Int

Function generated for derived instance.

pred ∷ Ordering → Ordering

Function generated for derived instance.

succ ∷ Ordering → Ordering

Function generated for derived instance.

instance (Eq a, Eq b) ⇒ Eq (a, b)

Member Functions

!= ∷ (Eq 𝖇, Eq 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → Bool
infix  7

inherited from Eq.!=

== ∷ (Eq 𝖇, Eq 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → Bool
infix  7

Function generated for derived instance.

hashCode ∷ (Eq 𝖇, Eq 𝖆) ⇒ (𝖇, 𝖆) → Int

Function generated for derived instance.

instance (Eq a, Eq b, Eq c) ⇒ Eq (a, b, c)

Member Functions

!= ∷ (Eq 𝖇, Eq 𝖈, Eq 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → Bool
infix  7

inherited from Eq.!=

== ∷ (Eq 𝖇, Eq 𝖈, Eq 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → Bool
infix  7

Function generated for derived instance.

hashCode ∷ (Eq 𝖇, Eq 𝖈, Eq 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → Int

Function generated for derived instance.

instance (Eq a, Eq b) ⇒ Eq (a | b)

Member Functions

!= ∷ (Eq 𝖇, Eq 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → Bool
infix  7

inherited from Eq.!=

== ∷ (Eq 𝖇, Eq 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → Bool
infix  7

Function generated for derived instance.

hashCode ∷ (Eq 𝖇, Eq 𝖆) ⇒ (𝖇 | 𝖆) → Int

Function generated for derived instance.

instance Eq Ordering

Member Functions

!= ∷ Ordering → Ordering → Bool
infix  7

inherited from Eq.!=

== ∷ Ordering → Ordering → Bool
infix  7

Function generated for derived instance.

hashCode ∷ Ordering → Int

Function generated for derived instance.

instance Ord ()

Member Functions

< ∷ () → () → Bool
infix  9

inherited from Ord.<

<= ∷ () → () → Bool
infix  9

inherited from Ord.<=

<=> ∷ () → () → Ordering
infix  8

Function generated for derived instance.

> ∷ () → () → Bool
infix  9

inherited from Ord.>

>= ∷ () → () → Bool
infix  9

inherited from Ord.>=

compare ∷ () → () → Ordering
infix  8

inherited from Ord.compare

max ∷ () → () → ()

inherited from Ord.max

min ∷ () → () → ()

inherited from Ord.min

instance (Ord a, Ord b) ⇒ Ord (a, b)

Member Functions

< ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → Bool
infix  9

inherited from Ord.<

<= ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → Bool
infix  9

inherited from Ord.<=

<=> ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → Ordering
infix  8

Function generated for derived instance.

> ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → Bool
infix  9

inherited from Ord.>

>= ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → Bool
infix  9

inherited from Ord.>=

compare ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → Ordering
infix  8

inherited from Ord.compare

max ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → (𝖇, 𝖆)

inherited from Ord.max

min ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → (𝖇, 𝖆)

inherited from Ord.min

instance (Ord a, Ord b, Ord c) ⇒ Ord (a, b, c)

Member Functions

< ∷ (Ord 𝖇, Ord 𝖈, Ord 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → Bool
infix  9

inherited from Ord.<

<= ∷ (Ord 𝖇, Ord 𝖈, Ord 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → Bool
infix  9

inherited from Ord.<=

<=> ∷ (Ord 𝖇, Ord 𝖈, Ord 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → Ordering
infix  8

Function generated for derived instance.

> ∷ (Ord 𝖇, Ord 𝖈, Ord 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → Bool
infix  9

inherited from Ord.>

>= ∷ (Ord 𝖇, Ord 𝖈, Ord 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → Bool
infix  9

inherited from Ord.>=

compare ∷ (Ord 𝖇, Ord 𝖈, Ord 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → Ordering
infix  8

inherited from Ord.compare

max ∷ (Ord 𝖇, Ord 𝖈, Ord 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆)

inherited from Ord.max

min ∷ (Ord 𝖇, Ord 𝖈, Ord 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆)

inherited from Ord.min

instance (Ord a, Ord b) ⇒ Ord (a | b)

Member Functions

< ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → Bool
infix  9

inherited from Ord.<

<= ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → Bool
infix  9

inherited from Ord.<=

<=> ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → Ordering
infix  8

Function generated for derived instance.

> ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → Bool
infix  9

inherited from Ord.>

>= ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → Bool
infix  9

inherited from Ord.>=

compare ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → Ordering
infix  8

inherited from Ord.compare

max ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → (𝖇 | 𝖆)

inherited from Ord.max

min ∷ (Ord 𝖇, Ord 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → (𝖇 | 𝖆)

inherited from Ord.min

instance Ord Ordering

Member Functions

< ∷ Ordering → Ordering → Bool
infix  9

inherited from Ord.<

<= ∷ Ordering → Ordering → Bool
infix  9

inherited from Ord.<=

<=> ∷ Ordering → Ordering → Ordering
infix  8

Function generated for derived instance.

> ∷ Ordering → Ordering → Bool
infix  9

inherited from Ord.>

>= ∷ Ordering → Ordering → Bool
infix  9

inherited from Ord.>=

compare ∷ Ordering → Ordering → Ordering
infix  8

inherited from Ord.compare

max ∷ Ordering → Ordering → Ordering

inherited from Ord.max

min ∷ Ordering → Ordering → Ordering

inherited from Ord.min

instance Show Decimal

Member Functions

display ∷ Decimal → String

inherited from Show.display

show ∷ Decimal → String

showChars ∷ Decimal → [Char]

inherited from Show.showChars

showList ∷ [Decimal] → String → String

inherited from Show.showList

showsPrec ∷ Int → Decimal → String → String

inherited from Show.showsPrec

showsub ∷ Decimal → String

inherited from Show.showsub

Functions and Values by Type

(String→String) → IO ()

interact

MutableIO Reader → IO String

getContentsOf

String → String → IO ()

appendFile, writeFile

String → (NumberFormatException | Decimal)

parseDecimal

String → IO String

readFile

String → IO ()

putStr, putStrLn

String → Bool

trace, traceLn

[Decimal] → String → String

Show_Decimal.showList

() → () → ()

Ord_().min, Ord_().max

() → () → Bool

Ord_().>=, Ord_().<, Ord_().<=, Ord_().>

() → () → Ordering

Ord_().compare, Ord_().<=>

Char → IO ()

putChar

Int → Decimal → String → String

Show_Decimal.showsPrec

Int → Ordering

Enum_Ordering.from

Ordering → Ordering → Ordering → [Ordering]

Enum_Ordering.enumFromThenTo

Ordering → Ordering → [Ordering]

Enum_Ordering.enumFromThen, Enum_Ordering.enumFromTo

Ordering → Ordering → Bool

Eq_Ordering.!=, Eq_Ordering.==, Ord_Ordering.>=, Ord_Ordering.<, Ord_Ordering.<=, Ord_Ordering.>

Ordering → Ordering → Ordering

Ord_Ordering.min, Ord_Ordering.compare, Ord_Ordering.max, Ord_Ordering.<=>

Ordering → [Ordering]

Enum_Ordering.enumFrom

Ordering → Int

Enum_Ordering.ord, Eq_Ordering.hashCode

Ordering → Ordering

Enum_Ordering.succ, Enum_Ordering.pred

Decimal → String

Show_Decimal.showsub, Show_Decimal.display, Show_Decimal.show

Decimal → [Char]

Show_Decimal.showChars

IO String

getContents, getLine

IO Char

getChar

Show 𝖆 ⇒ 𝖆 → IO ()

print, println

(Eq 𝖇, Eq 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → Bool

Eq_(,).!=, Eq_(,).==

(Eq 𝖇, Eq 𝖆) ⇒ (𝖇, 𝖆) → Int

Eq_(,).hashCode

(Eq 𝖇, Eq 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → Bool

Eq_Either.!=, Eq_Either.==

(Eq 𝖇, Eq 𝖆) ⇒ (𝖇 | 𝖆) → Int

Eq_Either.hashCode

(Ord 𝖇, Ord 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → (𝖇, 𝖆)

Ord_(,).min, Ord_(,).max

(Ord 𝖇, Ord 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → Bool

Ord_(,).>=, Ord_(,).<, Ord_(,).<=, Ord_(,).>

(Ord 𝖇, Ord 𝖆) ⇒ (𝖇, 𝖆) → (𝖇, 𝖆) → Ordering

Ord_(,).compare, Ord_(,).<=>

(Ord 𝖇, Ord 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → (𝖇 | 𝖆)

Ord_Either.min, Ord_Either.max

(Ord 𝖇, Ord 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → Bool

Ord_Either.>=, Ord_Either.<, Ord_Either.<=, Ord_Either.>

(Ord 𝖇, Ord 𝖆) ⇒ (𝖇 | 𝖆) → (𝖇 | 𝖆) → Ordering

Ord_Either.compare, Ord_Either.<=>

(Bounded 𝖇, Bounded 𝖆) ⇒ (𝖇, 𝖆)

Bounded_(,).maxBound, Bounded_(,).minBound

(Eq 𝖇, Eq 𝖈, Eq 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → Bool

Eq_(,,).!=, Eq_(,,).==

(Eq 𝖇, Eq 𝖈, Eq 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → Int

Eq_(,,).hashCode

(Ord 𝖇, Ord 𝖈, Ord 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆)

Ord_(,,).min, Ord_(,,).max

(Ord 𝖇, Ord 𝖈, Ord 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → Bool

Ord_(,,).>=, Ord_(,,).<, Ord_(,,).<=, Ord_(,,).>

(Ord 𝖇, Ord 𝖈, Ord 𝖆) ⇒ (𝖇, 𝖈, 𝖆) → (𝖇, 𝖈, 𝖆) → Ordering

Ord_(,,).compare, Ord_(,,).<=>

(Bounded 𝖇, Bounded 𝖈, Bounded 𝖆) ⇒ (𝖇, 𝖈, 𝖆)

Bounded_(,,).maxBound, Bounded_(,,).minBound