Novah Documentation

Modules

novah.core

novah.result

novah.number

novah.random

novah.java

novah.math

novah.meta

novah.linkedList

novah.option

novah.stream

novah.list

novah.map

novah.set

novah.regex

novah.string

novah.io

novah.test

novah.async

novah.computation

novah.array

novah.core

The core functions of the language. Imported automatically in every module.

Types

Option

visibility: public+
constructors: Some, None

Represents the possibility of a missing value.

Result

visibility: public+
constructors: Ok, Err

Represents a computation that can fail. Should be used to represent errors instead of exceptions.

Atom

visibility: public
constructors: Atom

Atoms are a shared, uncoordinated, synchronous reference to an immutable value.

Ordering

visibility: public+
constructors: GT, LT, EQ

The ordering type represents the outcome of comparing 2 values:

GT -> bigger than EQ -> equals LT -> less than

Tuple

visibility: public+
constructors: Tuple

A Tuple containing two values.

Sized

visibility: public+
constructors: Sized

The type of things that have size.

Concat

visibility: public+
constructors: Concat

The type of things that can be concatenated.

Plus

visibility: public+
constructors: Plus

The type of things that can be added together using the + operator.

Minus

visibility: public+
constructors: Minus

The type of things that can be subtracted using the - operator.

Mult

visibility: public+
constructors: Mult

The type of things that can be multiplied together using the * operator.

Divide

visibility: public+
constructors: Divide

The type of things that can be divided using the / operator.

Show

visibility: public+
constructors: Show

The type of things that have a String representation.

Equals

visibility: public+
constructors: Equals

The type of things that support equality comparison.

Contained

visibility: public+
constructors: Contained

The type of things that can contain other values. The first type variable is the type of the contained value, the second is the type of the container itself. Ex.: Contained a (List a)

Ord

visibility: public+
constructors: Ord

The type of things that can be ordered.

NumberOps

visibility: public+
constructors: NumberOps

A type for some miscelaneous number operations.

ToNumber

visibility: public+
constructors: ToNumber

Types that can be converted to numbers. Many of these conversions are unsafe like int64 -> int, String -> int, etc. Booleans are converted to 1 for true and 0 for false.

BitOperator

visibility: public+
constructors: BitOperator

Represents a type that supports bitwise operations.

Ranged

visibility: public+
constructors: Ranged

Types that can range over some values.

RangedStep

visibility: public+
constructors: RangedStep

Types that can range over some values with a step.

Declarations

Some

visibility: public
type: t171 -> Option t171

None

visibility: public
type: Option t171

Ok

visibility: public
type: t172 -> Result t172 t173

Err

visibility: public
type: t173 -> Result t172 t173

Atom

visibility: private
type: AtomicReference t174 -> Atom t174

GT

visibility: public
type: Ordering

LT

visibility: public
type: Ordering

EQ

visibility: public
type: Ordering

Tuple

visibility: public
type: t175 -> t176 -> Tuple t175 t176

Sized

visibility: public
type: (t177 -> Int32) -> Sized t177

Concat

visibility: public
type: (t178 -> t178 -> t178) -> Concat t178

Plus

visibility: public
type: { identity : t179, plus : t179 -> t179 -> t179 } -> Plus t179

Minus

visibility: public
type: (t180 -> t180 -> t180) -> Minus t180

Mult

visibility: public
type: { identity : t181, mult : t181 -> t181 -> t181 } -> Mult t181

Divide

visibility: public
type: (t182 -> t182 -> t182) -> Divide t182

Show

visibility: public
type: (t183 -> String) -> Show t183

Equals

visibility: public
type: (t184 -> t184 -> Boolean) -> Equals t184

Contained

visibility: public
type: Equals t185 -> (t185 -> t186 -> Boolean) -> Contained t185 t186

Ord

visibility: public
type: Equals t187 -> { compare : t187 -> t187 -> Ordering } -> Ord t187

NumberOps

visibility: public
type: { abs : t188 -> t188, even : t188 -> Boolean, max : t188 -> t188 -> t188, min : t188 -> t188 -> t188, remainder : t188 -> t188 -> t188 } -> NumberOps t188

ToNumber

visibility: public
type: { float32 : t189 -> Float32, float64 : t189 -> Float64, int : t189 -> Int32, int64 : t189 -> Int64 } -> ToNumber t189

BitOperator

visibility: public
type: { and : t190 -> t190 -> t190, not : t190 -> t190, or : t190 -> t190 -> t190, shiftLeft : t190 -> t190 -> t190, shiftRight : t190 -> t190 -> t190, unsignedShiftRight : t190 -> t190 -> t190, xor : t190 -> t190 -> t190 } -> BitOperator t190

Ranged

visibility: public
type: { range : t191 -> t191 -> Range t191, rangeOpen : t191 -> t191 -> Range t191 } -> Ranged t191

RangedStep

visibility: public
type: { range : t192 -> t192 -> t192 -> Range t192, rangeOpen : t192 -> t192 -> t192 -> Range t192 } -> RangedStep t192

unsafeCast

visibility: public
type: a -> b

Coerce parameter x from type a to b. This is extremely unsafe and should be used only when sure both types are compatible, otherwise a runtime exception will be thrown.

not

visibility: public
type: Boolean -> Boolean

Negates a boolean value.

xor

visibility: public
type: Boolean -> Boolean -> Boolean

Returns the exclusive disjunction of p and q.

identity

visibility: public
type: a -> a

Returns its argument unmodified.

flip

visibility: public
type: (a -> b -> c) -> b -> a -> c

Flips the arguments of a 2-arguments function.

const

visibility: public
type: a -> b -> a

Takes two parameters and returns the first, ignoring the second.

|>

visibility: public
type: a -> (a -> b) -> b

The railway operator. Applies function f to x. Used to minimize parentheses and have a more intuitive order of execution:

1 .. 100 |> List.reverse |> List.map (_ * 10) instead of List.map (_ * 10) (List.reverse (1 .. 100))

<|

visibility: public
type: (a -> b) -> a -> b

The reverse of the |> (railway operator). Applies function f to x. Used to minimize parentheses:

List.map (_ * 10) <| List.reverse <| 1 .. 100 instead of List.map (_ * 10) (List.sort (1 .. 100))

>>

visibility: public
type: (a -> b) -> (b -> c) -> a -> c

Forward function composition operator: (f >> g) x = g (f x)

<<

visibility: public
type: (b -> c) -> (a -> b) -> a -> c

Backward function composition operator: (f << g) x = f (g x)

===

visibility: public
type: a -> a -> Boolean

Returns true if the 2 references point to the same object. This is the same as Java's ==

!==

visibility: public
type: a -> a -> Boolean

Returns true if the 2 objects do not point to the same object. This is the same as Java's !=

&&

visibility: public
type: Boolean -> Boolean -> Boolean

Logical and operator. Returns true if both conditions are true. This operator will short circuit if fully applied.

||

visibility: public
type: Boolean -> Boolean -> Boolean

Logical or operator. Returns true if at least one of the conditions is true. This operator will short circuit if fully applied.

println

visibility: public
type: a -> Unit

Prints x to stdout and appends a new line.

print

visibility: public
type: a -> Unit

Prints x to the stdout.

toString

visibility: public
type: a -> String

Converts a value to String using the native Java toString method.

todo

visibility: public
type: String -> a

Throws an exception stating that this code is still undergoing implementation. Should be used a placeholder for future code.

!

visibility: public
type: List a -> Int32 -> a

Returns some value at index for this list if it exists. Unsafe: Will throw an exception if the index is out of bounds. This function is similar to the index operator list.[i] but it does not work on negative indexes.

setAt

visibility: public
type: Int32 -> a -> List a -> List a

Sets the value of this list at the specified index to x. Unsafe: Will throw a java.lang.IndexOutOfBoundsException if the index doesn't exist. Runtime: ~O(1)

updateAt

visibility: public
type: Int32 -> (a -> a) -> List a -> List a

Updates the value of this list at the specified index by applying function f to the old value. Unsafe: Will throw a java.lang.IndexOutOfBoundsException if the index doesn't exist. Runtime: ~O(1)

addFirst

visibility: public
type: a -> List a -> List a

Appends x to the beginning of this list. Runtime: ~O(1)

addLast

visibility: public
type: a -> List a -> List a

Appends x to the end of this list. Runtime: ~O(1)

removeFirst

visibility: public
type: List a -> List a

Removes the first element of this list. Runtime: ~O(1)

removeLast

visibility: public
type: List a -> List a

Removes the last element of this list. Runtime: ~O(1)

aget

visibility: public
type: Int32 -> Array a -> a

Gets the element of the array at the specified index. Unsafe: Will thrown a java.lang.IndexOutOfBoundsException if the index doesn't exist. Runtime: O(1)

aset

visibility: public
type: Int32 -> a -> Array a -> Unit

Sets the element of the array at the specified index. Unsafe: Will thrown a java.lang.IndexOutOfBoundsException if the index doesn't exist. Runtime: O(1)

aupdate

visibility: public
type: Int32 -> (a -> a) -> Array a -> Unit

Updates the element of the array at the specified index by applying this function to the old value. Unsafe: Will thrown a java.lang.IndexOutOfBoundsException if the index doesn't exist. Runtime: O(1)

arrayOf

visibility: public
type: Class a -> Int32 -> Array a

Creates an array of the specified class and size.

format

visibility: public
type: String -> List a -> String

Returns a formatted string using the specified format string and arguments. See java.util.Formatter for format explanation.

printfln

visibility: public
type: String -> List a -> Unit

Prints the formated string to stdout.

nullable

visibility: public
type: a -> Nullable a

Coerces a value to a nullable. Should only be used for Java interoperability when a foreign imported value can be null or a method can return null. let possibleNullResult = obj#foreignFunction(x, y, z) |> nullable

?:

visibility: public
type: Option a -> a -> a

Returns the value contained in this option or the default value.

unwrapOption

visibility: public
type: Option a -> a

Extracts the value out of this option. Unsafe: Will thrown an exception if the option is empty. The !! syntactic sugar can be used instead, but this function still needs to be in scope.

?

visibility: public
type: Option a -> (a -> Option b) -> Option b

Threads optional values together stopping as soon as the option is empty. This is a flipped version of Option.flatMap. Ex.:

List.nth 1 [[1, 2], [3, 4]] ? List.nth 5 ?: 0

??

visibility: public
type: Option a -> (a -> b) -> Option b

Maps the function inside the option if it's not empty. This is a flipped version of Option.map. Ex.:

Some [1, 2, 3] ?? List.size

atom

visibility: public
type: a -> Atom a

Creates a new Atom to hold x. Should not be used to hold a mutable value.

deref

visibility: public
type: Atom a -> a

Returns the value inside this Atom.

reset

visibility: public
type: a -> Atom a -> a

Resets the value of this Atom to x, discarding the old value. Returns x.

swap

visibility: public
type: (a -> a) -> Atom a -> a

Swaps the value of this atom by applying a function to the old value. The function should be free of side effects as it may be executed multiple times.

compareAndSet

visibility: public
type: a -> a -> Atom a -> Boolean

Low-level function that receives the old value, the new value and attempts to set the atom to new if old matches. Returns true if it succeeded. Always prefer swap over compareAndSet.

^

visibility: public
type: Float64 -> Float64 -> Float64

Returns x raised to the power of y. Follows the same special cases as java.lang.Math.pow.

fst

visibility: public
type: Tuple a b -> a

Returns the first element of this tuple. Runtime: O(1)

snd

visibility: public
type: Tuple a b -> b

Returns the second element of this tuple. Runtime: O(1)

len

visibility: public
type: {{ Sized a }} -> a -> Int32

Returns the length of this sized value.

sizedString

visibility: public
type: Sized String

sizedList

visibility: public
type: Sized (List a)

sizedSet

visibility: public
type: Sized (Set a)

sizedMap

visibility: public
type: Sized (Map k v)

sizedArray

visibility: public
type: Sized (Array a)

sizedByteArray

visibility: public
type: Sized ByteArray

sizedInt16Array

visibility: public
type: Sized Int16Array

sizedInt32Array

visibility: public
type: Sized Int32Array

sizedInt64Array

visibility: public
type: Sized Int64Array

sizedFloat32Array

visibility: public
type: Sized Float32Array

sizedFloat64Array

visibility: public
type: Sized Float64Array

sizedBooleanArray

visibility: public
type: Sized BooleanArray

sizedCharArray

visibility: public
type: Sized CharArray

++

visibility: public
type: {{ Concat a }} -> a -> a -> a

Concatenate 2 concatenable values together.

concatString

visibility: public
type: Concat String

concatList

visibility: public
type: Concat (List a)

concatSet

visibility: public
type: Concat (Set a)

concatOption_

visibility: private
type: Concat a -> Option a -> Option a -> Option a

concatOption

visibility: public
type: {{ Concat a }} -> Concat (Option a)

concatTup

visibility: private
type: Concat a -> Concat b -> Tuple a b -> Tuple a b -> Tuple a b

concatTuple

visibility: public
type: {{ Concat a }} -> {{ Concat b }} -> Concat (Tuple a b)

+

visibility: public
type: {{ Plus a }} -> a -> a -> a

Adds x and y.

plusInt32

visibility: public
type: Plus Int32

plusInt64

visibility: public
type: Plus Int64

plusFloat32

visibility: public
type: Plus Float32

plusFloat64

visibility: public
type: Plus Float64

plusTup

visibility: private
type: Plus a -> Plus b -> Tuple a b -> Tuple a b -> Tuple a b

plusTuple

visibility: public
type: {{ Plus a }} -> {{ Plus b }} -> Plus (Tuple a b)

-

visibility: public
type: {{ Minus a }} -> a -> a -> a

Subtracts x and y.

minusInt32

visibility: public
type: Minus Int32

minusInt64

visibility: public
type: Minus Int64

minusFloat32

visibility: public
type: Minus Float32

minusFloat64

visibility: public
type: Minus Float64

minusTup

visibility: private
type: Minus a -> Minus b -> Tuple a b -> Tuple a b -> Tuple a b

minusTuple

visibility: public
type: {{ Minus a }} -> {{ Minus b }} -> Minus (Tuple a b)

*

visibility: public
type: {{ Mult a }} -> a -> a -> a

Multiplies x and y.

multInt32

visibility: public
type: Mult Int32

multInt64

visibility: public
type: Mult Int64

multFloat32

visibility: public
type: Mult Float32

multFloat64

visibility: public
type: Mult Float64

multTup

visibility: private
type: Mult a -> Mult b -> Tuple a b -> Tuple a b -> Tuple a b

multTuple

visibility: public
type: {{ Mult a }} -> {{ Mult b }} -> Mult (Tuple a b)

/

visibility: public
type: {{ Divide a }} -> a -> a -> a

Divides x by y.

divideInt32

visibility: public
type: Divide Int32

divideInt64

visibility: public
type: Divide Int64

divideFloat32

visibility: public
type: Divide Float32

divideFloat64

visibility: public
type: Divide Float64

divideTup

visibility: private
type: Divide a -> Divide b -> Tuple a b -> Tuple a b -> Tuple a b

divideTuple

visibility: public
type: {{ Divide a }} -> {{ Divide b }} -> Divide (Tuple a b)

show

visibility: public
type: {{ Show a }} -> a -> String

Converts this value to a String.

printlnShow

visibility: public
type: {{ Show a }} -> a -> Unit

Prints x to stdout and appends a new line. Transforms the argument to a String using show first.

printShow

visibility: public
type: {{ Show a }} -> a -> Unit

Prints x to stdout. Transforms the argument to a String using show first.

showString

visibility: public
type: Show String

showByte

visibility: public
type: Show Byte

showInt16

visibility: public
type: Show Int16

showInt32

visibility: public
type: Show Int32

showInt64

visibility: public
type: Show Int64

showFloat32

visibility: public
type: Show Float32

showFloat64

visibility: public
type: Show Float64

showChar

visibility: public
type: Show Char

showBoolean

visibility: public
type: Show Boolean

showObject

visibility: public
type: Show Object

showOpt

visibility: private
type: Show a -> Option a -> String

showOption

visibility: public
type: {{ Show a }} -> Show (Option a)

showList

visibility: public
type: {{ Show a }} -> Show (List a)

showSet

visibility: public
type: {{ Show a }} -> Show (Set a)

showArray

visibility: public
type: {{ Show a }} -> Show (Array a)

showNull

visibility: private
type: Show a -> Nullable a -> String

showNullable

visibility: public
type: {{ Show a }} -> Show (Nullable a)

showOrdering

visibility: public
type: Show Ordering

showRes

visibility: private
type: Show ok -> Show err -> Result ok err -> String

showResult

visibility: public
type: {{ Show ok }} -> {{ Show err }} -> Show (Result ok err)

showAtom

visibility: public
type: {{ Show a }} -> Show (Atom a)

showTup

visibility: private
type: Show a -> Show b -> Tuple a b -> String

showTuple

visibility: public
type: {{ Show a }} -> {{ Show b }} -> Show (Tuple a b)

showRange

visibility: public
type: {{ Show a }} -> Show (Range a)

==

visibility: public
type: {{ Equals a }} -> a -> a -> Boolean

Returns true if the two values are equal.

!=

visibility: public
type: {{ Equals a }} -> a -> a -> Boolean

Returns true if the two values are not equal.

eqByte

visibility: public
type: Equals Byte

eqInt16

visibility: public
type: Equals Int16

eqInt32

visibility: public
type: Equals Int32

eqInt64

visibility: public
type: Equals Int64

eqFloat32

visibility: public
type: Equals Float32

eqFloat64

visibility: public
type: Equals Float64

eqChar

visibility: public
type: Equals Char

equalsBoolean

visibility: private
type: Boolean -> Boolean -> Boolean

eqBoolean

visibility: public
type: Equals Boolean

eqString

visibility: public
type: Equals String

eqList

visibility: public
type: {{ Equals a }} -> Equals (List a)

eqSet

visibility: public
type: {{ Equals a }} -> Equals (Set a)

eqArray

visibility: public
type: {{ Equals a }} -> Equals (Array a)

equalsOption

visibility: private
type: Equals a -> Option a -> Option a -> Boolean

eqOption

visibility: public
type: {{ Equals a }} -> Equals (Option a)

equalsNullable

visibility: private
type: Equals a -> Nullable a -> Nullable a -> Boolean

eqNullable

visibility: public
type: {{ Equals a }} -> Equals (Nullable a)

eqObject

visibility: public
type: Equals Object

equalsOrdering

visibility: private
type: Ordering -> Ordering -> Boolean

eqOrdering

visibility: public
type: Equals Ordering

equalsResult

visibility: private
type: Equals ok -> Equals err -> Result ok err -> Result ok err -> Boolean

eqResult

visibility: public
type: {{ Equals ok }} -> {{ Equals err }} -> Equals (Result ok err)

equalsAtom

visibility: private
type: Equals a -> Atom a -> Atom a -> Boolean

eqAtom

visibility: public
type: {{ Equals a }} -> Equals (Atom a)

equalsTuple

visibility: private
type: Equals a -> Equals b -> Tuple a b -> Tuple a b -> Boolean

eqTuple

visibility: public
type: {{ Equals a }} -> {{ Equals b }} -> Equals (Tuple a b)

equalsRange

visibility: public
type: {{ Equals a }} -> Equals (Range a)

recordEquals

visibility: public
type: { | r } -> { | r } -> Boolean

Compare if the two records are equals according to Java's equality.

isIn

visibility: public
type: {{ Contained a fa }} -> a -> fa -> Boolean

Returns true if x is inside the container.

notIn

visibility: public
type: {{ Contained a fa }} -> a -> fa -> Boolean

Returns true if x is not inside the container.

containedSet

visibility: public
type: {{ Equals a }} -> Contained a (Set a)

containedList

visibility: public
type: {{ Equals a }} -> Contained a (List a)

containedOption

visibility: public
type: {{ Equals a }} -> Contained a (Option a)

containedResult

visibility: public
type: {{ Equals a }} -> Contained a (Result a a)

containedRange

visibility: public
type: {{ Equals a }} -> Contained a (Range a)

compare

visibility: public
type: {{ Ord a }} -> a -> a -> Ordering

Returns the result of comparing two Ord instances.

>

visibility: public
type: {{ Ord a }} -> a -> a -> Boolean

Returns true if x is greater than y.

<

visibility: public
type: {{ Ord a }} -> a -> a -> Boolean

Returns true if x is smaller than y.

>=

visibility: public
type: {{ Ord a }} -> a -> a -> Boolean

Returns true if x is greater than or equal y.

containedString

visibility: public
type: Contained String String

containedCharString

visibility: public
type: Contained Char String

<=

visibility: public
type: {{ Ord a }} -> a -> a -> Boolean

Returns true if x is smaller than or equal y.

ordInt32

visibility: public
type: Ord Int32

ordInt64

visibility: public
type: Ord Int64

ordFloat64

visibility: public
type: Ord Float64

ordByte

visibility: public
type: Ord Byte

ordInt16

visibility: public
type: Ord Int16

ordFloat32

visibility: public
type: Ord Float32

ordChar

visibility: public
type: Ord Char

compareBoolean

visibility: private
type: Boolean -> Boolean -> Ordering

ordBoolean

visibility: public
type: Ord Boolean

ordString

visibility: public
type: Ord String

compareOption

visibility: private
type: Ord a -> Option a -> Option a -> Ordering

ordOption

visibility: public
type: {{ Ord a }} -> Ord (Option a)

Compares two options if their values are comparable. None values are always smaller then Some.

%

visibility: public
type: {{ NumberOps a }} -> a -> a -> a

Returns the remainder of dividing x by y.

numberOpsInt32

visibility: public
type: NumberOps Int32

numberOpsInt64

visibility: public
type: NumberOps Int64

numberOpsFloat32

visibility: public
type: NumberOps Float32

numberOpsFloat64

visibility: public
type: NumberOps Float64

int

visibility: public
type: {{ ToNumber a }} -> a -> Int32

Converts this value to a 32-bit integer.

int64

visibility: public
type: {{ ToNumber a }} -> a -> Int64

Converts this value to a 64-bit integer.

float32

visibility: public
type: {{ ToNumber a }} -> a -> Float32

Converts this value to a 32-bit float.

float64

visibility: public
type: {{ ToNumber a }} -> a -> Float64

Converts this value to a 64-bit float.

toNumberInt32

visibility: public
type: ToNumber Int32

toNumberInt64

visibility: public
type: ToNumber Int64

toNumberFloat32

visibility: public
type: ToNumber Float32

toNumberFloat64

visibility: public
type: ToNumber Float64

toNumberChar

visibility: public
type: ToNumber Char

toNumberString

visibility: public
type: ToNumber String

toNumberBoolean

visibility: public
type: ToNumber Boolean

bitAnd

visibility: public
type: {{ BitOperator a }} -> a -> a -> a

Returns the biwise and between x and y. Equivalent to Java's &.

bitOr

visibility: public
type: {{ BitOperator a }} -> a -> a -> a

Returns the biwise or between x and y. Equivalent to Java's |.

bitXor

visibility: public
type: {{ BitOperator a }} -> a -> a -> a

Returns the biwise xor between x and y. Equivalent to Java's ^.

bitNot

visibility: public
type: {{ BitOperator a }} -> a -> a

Returns the bit complement of x. Equivalent to Java's ~.

bitShiftLeft

visibility: public
type: {{ BitOperator a }} -> a -> a -> a

Shifts x bitwise to the left by amount. Equivalent to Java's <<.

bitShiftRight

visibility: public
type: {{ BitOperator a }} -> a -> a -> a

Shifts x bitwise to the right by amount. Equivalent to Java's >>.

bitUnsignedShiftRight

visibility: public
type: {{ BitOperator a }} -> a -> a -> a

Shifts x bitwise to the right by amount (unsigned). Equivalent to Java's >>>.

bitOperatorByte

visibility: public
type: BitOperator Byte

bitOperatorInt16

visibility: public
type: BitOperator Int16

bitOperatorInt32

visibility: public
type: BitOperator Int32

bitOperatorInt64

visibility: public
type: BitOperator Int64

..

visibility: public
type: {{ Ranged a }} -> a -> a -> Range a

Returns a range from begin (inclusive) to end (inclusive). If start > end the range will go down instead of up. Runtime: O(1)

...

visibility: public
type: {{ Ranged a }} -> a -> a -> Range a

Returns a range from begin (inclusive) to end (exclusive). If start > end the range will go down instead of up. Runtime: O(1)

range

visibility: public
type: {{ RangedStep a }} -> a -> a -> a -> Range a

Returns a range between begin (inclusive) and end (inclusive) going step by step. Runtime: O(1)

rangeOpen

visibility: public
type: {{ RangedStep a }} -> a -> a -> a -> Range a

Returns a range between begin (inclusive) and end (exclusive) going step by step. Runtime: O(1)

forEachRange

visibility: public
type: Range a -> (a -> Unit) -> Unit

Executes the function for every value in this range.

rangeToList

visibility: public
type: Range a -> List a

Returns a list with all the elements of this range.

rangeToSet

visibility: public
type: Range a -> Set a

Returns a set with all the elements of this range.

rangeStart

visibility: public
type: Range a -> a

The starting value of this range.

rangeEnd

visibility: public
type: Range a -> a

The ending value of this range.

rangedInt32

visibility: public
type: Ranged Int32

rangedInt64

visibility: public
type: Ranged Int64

rangedFloat32

visibility: public
type: Ranged Float32

rangedFloat64

visibility: public
type: Ranged Float64

rangedChar

visibility: public
type: Ranged Char

rangedStepInt32

visibility: public
type: RangedStep Int32

rangedStepInt64

visibility: public
type: RangedStep Int64

rangedStepChar

visibility: public
type: RangedStep Char