Enum HaskellType 

pub enum HaskellType {
    Int,
    Integer,
    Double,
    Float,
    Bool,
    Char,
    HsString,
    Unit,
    IO(Box<HaskellType>),
    List(Box<HaskellType>),
    Maybe(Box<HaskellType>),
    Either(Box<HaskellType>, Box<HaskellType>),
    Tuple(Vec<HaskellType>),
    Fun(Box<HaskellType>, Box<HaskellType>),
    Custom(String),
    Polymorphic(String),
    Constraint(String, Vec<HaskellType>),
}

Haskell type representation for type-directed code generation.

Variants

Int

Int — fixed-precision signed integer (at least 30-bit)

Integer

Integer — arbitrary-precision integer

Double

Double — 64-bit IEEE floating-point

Float

Float — 32-bit IEEE floating-point

Bool

Bool — boolean

Char

Char — Unicode character

HsString

String — alias for [Char]

Unit

() — unit type

IO(Box<HaskellType>)

IO a — IO monad

List(Box<HaskellType>)

[a] — list of a

Maybe(Box<HaskellType>)

Maybe a — optional value

Either(Box<HaskellType>, Box<HaskellType>)

Either a b — sum type

Tuple(Vec<HaskellType>)

(a, b, ...) — tuple

Fun(Box<HaskellType>, Box<HaskellType>)

a -> b — function type

Custom(String)

Named type (data, newtype, type synonym)

Polymorphic(String)

Polymorphic type variable: a, b, f

Constraint(String, Vec<HaskellType>)

Type class constraint: Eq a, Functor f

Trait Implementations

impl Clone for HaskellType

fn clone(&self) -> HaskellType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HaskellType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for HaskellType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for HaskellType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for HaskellType

fn eq(&self, other: &HaskellType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for HaskellType

impl StructuralPartialEq for HaskellType