Delude

Documentation

class Boolish b where

Boolish things are things which you can do boolean operations on.

Minimal complete definition

(||), (&&), (^), iff, implies, not, true, false

Methods

(||), (&&), (^), iff, implies :: b -> b -> b

not :: b -> b

true, false :: b

Instances

Boolish Bool

Bool itself is a Boolish thing.

Methods

(||) :: Bool -> Bool -> Bool

(&&) :: Bool -> Bool -> Bool

(^) :: Bool -> Bool -> Bool

iff :: Bool -> Bool -> Bool

implies :: Bool -> Bool -> Bool

not :: Bool -> Bool

true :: Bool

false :: Bool

Boolish b => Boolish (x -> b)

Functions which return Boolish things are also rather Boolish, | as you can just lift the functions of the Boolish below up a level | of lambda abstraction.

Methods

(||) :: (x -> b) -> (x -> b) -> x -> b

(&&) :: (x -> b) -> (x -> b) -> x -> b

(^) :: (x -> b) -> (x -> b) -> x -> b

iff :: (x -> b) -> (x -> b) -> x -> b

implies :: (x -> b) -> (x -> b) -> x -> b

not :: (x -> b) -> x -> b

true :: x -> b

false :: x -> b

module Prelude

module Control.Monad

module Data.Foldable

liftf1 :: (b -> b) -> (a -> b) -> a -> b

I really don't quite now how to describe this in words yet.

liftf2 :: (b -> b -> b) -> (a -> b) -> (a -> b) -> a -> b

Same as liftf1... Seems like a pretty general thing for inductive definitions.

class Enumerable e where

A class which supplies you with a (possibly infinite) enumeration of all of the types which instantiate it.

Minimal complete definition

enumeration

Methods

enumeration :: [e]

Orphan instances

Floating f => Floating (a -> f)

Finally, I've lifted the Floating interface.

Methods

pi :: a -> f

exp :: (a -> f) -> a -> f

log :: (a -> f) -> a -> f

sqrt :: (a -> f) -> a -> f

(**) :: (a -> f) -> (a -> f) -> a -> f

logBase :: (a -> f) -> (a -> f) -> a -> f

sin :: (a -> f) -> a -> f

cos :: (a -> f) -> a -> f

tan :: (a -> f) -> a -> f

asin :: (a -> f) -> a -> f

acos :: (a -> f) -> a -> f

atan :: (a -> f) -> a -> f

sinh :: (a -> f) -> a -> f

cosh :: (a -> f) -> a -> f

tanh :: (a -> f) -> a -> f

asinh :: (a -> f) -> a -> f

acosh :: (a -> f) -> a -> f

atanh :: (a -> f) -> a -> f

log1p :: (a -> f) -> a -> f

expm1 :: (a -> f) -> a -> f

log1pexp :: (a -> f) -> a -> f

log1mexp :: (a -> f) -> a -> f

Fractional f => Fractional (a -> f)

The same applies for Fractional things as Boolish and Num.

Methods

(/) :: (a -> f) -> (a -> f) -> a -> f

recip :: (a -> f) -> a -> f

fromRational :: Rational -> a -> f

Num n => Num (a -> n)

The same thing that is done to Boolish things, this lifting | of abstractions, can be done for Num instances.

Methods

(+) :: (a -> n) -> (a -> n) -> a -> n

(-) :: (a -> n) -> (a -> n) -> a -> n

(*) :: (a -> n) -> (a -> n) -> a -> n

negate :: (a -> n) -> a -> n

abs :: (a -> n) -> a -> n

signum :: (a -> n) -> a -> n

fromInteger :: Integer -> a -> n