# `Beaver.MLIR.Type`

This module provides functions to work with MLIR's type system, allowing creation of MLIR type.

## Type Categories

### Basic Types
- `integer/1` (`i32/1`, `i64/1`, etc.)
- `float/1` (`f32/1`, `f64/1`, etc.)
- `index/1`
- `none/1`

### Composite Types
- Tensors (`ranked_tensor/2` and `unranked_tensor/1`)
- `vector/2`
- `memref/3`
- `function/3`

# `t`

```elixir
@type t() :: %Beaver.MLIR.Type{ref: term()}
```

# `amdgputdm_base?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAAMDGPUTDMBaseType/1` to check if it is AMDGPUTDMBase type.

# `amdgputdm_descriptor`

calls `Beaver.MLIR.CAPI.mlirAMDGPUTDMDescriptorTypeGet/1` to get AMDGPUTDMDescriptor type

# `amdgputdm_descriptor?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAAMDGPUTDMDescriptorType/1` to check if it is AMDGPUTDMDescriptor type.

# `amdgputdm_gather_base?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAAMDGPUTDMGatherBaseType/1` to check if it is AMDGPUTDMGatherBase type.

# `any_quantized?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAAnyQuantizedType/1` to check if it is AnyQuantized type.

# `bf16`

calls `Beaver.MLIR.CAPI.mlirBF16TypeGet/1` to get BF16 type

# `bf16?`

calls `Beaver.MLIR.CAPI.mlirTypeIsABF16/1` to check if it is BF16 type.

# `calibrated_quantized?`

calls `Beaver.MLIR.CAPI.mlirTypeIsACalibratedQuantizedType/1` to check if it is CalibratedQuantized type.

# `complex`

# `complex?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAComplex/1` to check if it is Complex type.

# `dynamic?`

calls `Beaver.MLIR.CAPI.mlirTypeIsADynamicType/1` to check if it is Dynamic type.

# `element_type`

# `emit_c_array?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAEmitCArrayType/1` to check if it is EmitCArray type.

# `emit_c_opaque?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAEmitCOpaqueType/1` to check if it is EmitCOpaque type.

# `emit_c_pointer`

calls `Beaver.MLIR.CAPI.mlirEmitCPointerTypeGet/1` to get EmitCPointer type

# `emit_c_pointer?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAEmitCPointerType/1` to check if it is EmitCPointer type.

# `emit_c_ptr_diff_t`

calls `Beaver.MLIR.CAPI.mlirEmitCPtrDiffTTypeGet/1` to get EmitCPtrDiffT type

# `emit_c_ptr_diff_t?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAEmitCPtrDiffTType/1` to check if it is EmitCPtrDiffT type.

# `emit_c_signed_size_t`

calls `Beaver.MLIR.CAPI.mlirEmitCSignedSizeTTypeGet/1` to get EmitCSignedSizeT type

# `emit_c_signed_size_t?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAEmitCSignedSizeTType/1` to check if it is EmitCSignedSizeT type.

# `emit_c_size_t`

calls `Beaver.MLIR.CAPI.mlirEmitCSizeTTypeGet/1` to get EmitCSizeT type

# `emit_c_size_t?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAEmitCSizeTType/1` to check if it is EmitCSizeT type.

# `emit_cl_value`

calls `Beaver.MLIR.CAPI.mlirEmitCLValueTypeGet/1` to get EmitCLValue type

# `emit_cl_value?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAEmitCLValueType/1` to check if it is EmitCLValue type.

# `f16`

calls `Beaver.MLIR.CAPI.mlirF16TypeGet/1` to get F16 type

# `f16?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAF16/1` to check if it is F16 type.

# `f32`

calls `Beaver.MLIR.CAPI.mlirF32TypeGet/1` to get F32 type

# `f32?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAF32/1` to check if it is F32 type.

# `f64`

calls `Beaver.MLIR.CAPI.mlirF64TypeGet/1` to get F64 type

# `f64?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAF64/1` to check if it is F64 type.

# `f`

# `float4_e2_m1_fn`

calls `Beaver.MLIR.CAPI.mlirFloat4E2M1FNTypeGet/1` to get Float4E2M1FN type

# `float4_e2_m1_fn?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat4E2M1FN/1` to check if it is Float4E2M1FN type.

# `float6_e2_m3_fn`

calls `Beaver.MLIR.CAPI.mlirFloat6E2M3FNTypeGet/1` to get Float6E2M3FN type

# `float6_e2_m3_fn?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat6E2M3FN/1` to check if it is Float6E2M3FN type.

# `float6_e3_m2_fn`

calls `Beaver.MLIR.CAPI.mlirFloat6E3M2FNTypeGet/1` to get Float6E3M2FN type

# `float6_e3_m2_fn?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat6E3M2FN/1` to check if it is Float6E3M2FN type.

# `float8_e3_m4`

calls `Beaver.MLIR.CAPI.mlirFloat8E3M4TypeGet/1` to get Float8E3M4 type

# `float8_e3_m4?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat8E3M4/1` to check if it is Float8E3M4 type.

# `float8_e4_m3`

calls `Beaver.MLIR.CAPI.mlirFloat8E4M3TypeGet/1` to get Float8E4M3 type

# `float8_e4_m3?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat8E4M3/1` to check if it is Float8E4M3 type.

# `float8_e4_m3_b11_fnuz`

calls `Beaver.MLIR.CAPI.mlirFloat8E4M3B11FNUZTypeGet/1` to get Float8E4M3B11FNUZ type

# `float8_e4_m3_b11_fnuz?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat8E4M3B11FNUZ/1` to check if it is Float8E4M3B11FNUZ type.

# `float8_e4_m3_fn`

calls `Beaver.MLIR.CAPI.mlirFloat8E4M3FNTypeGet/1` to get Float8E4M3FN type

# `float8_e4_m3_fn?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat8E4M3FN/1` to check if it is Float8E4M3FN type.

# `float8_e4_m3_fnuz`

calls `Beaver.MLIR.CAPI.mlirFloat8E4M3FNUZTypeGet/1` to get Float8E4M3FNUZ type

# `float8_e4_m3_fnuz?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat8E4M3FNUZ/1` to check if it is Float8E4M3FNUZ type.

# `float8_e5_m2`

calls `Beaver.MLIR.CAPI.mlirFloat8E5M2TypeGet/1` to get Float8E5M2 type

# `float8_e5_m2?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat8E5M2/1` to check if it is Float8E5M2 type.

# `float8_e5_m2_fnuz`

calls `Beaver.MLIR.CAPI.mlirFloat8E5M2FNUZTypeGet/1` to get Float8E5M2FNUZ type

# `float8_e5_m2_fnuz?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat8E5M2FNUZ/1` to check if it is Float8E5M2FNUZ type.

# `float8_e5_m3_fnu`

calls `Beaver.MLIR.CAPI.mlirFloat8E5M3FNUTypeGet/1` to get Float8E5M3FNU type

# `float8_e5_m3_fnu?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat8E5M3FNU/1` to check if it is Float8E5M3FNU type.

# `float8_e8_m0_fnu`

calls `Beaver.MLIR.CAPI.mlirFloat8E8M0FNUTypeGet/1` to get Float8E8M0FNU type

# `float8_e8_m0_fnu?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat8E8M0FNU/1` to check if it is Float8E8M0FNU type.

# `float`

# `float?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFloat/1` to check if it is Float type.

# `function`

# `function?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAFunction/1` to check if it is Function type.

# `get`

# `gpu_async_token`

calls `Beaver.MLIR.CAPI.mlirGPUAsyncTokenTypeGet/1` to get GPUAsyncToken type

# `gpu_async_token?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAGPUAsyncTokenType/1` to check if it is GPUAsyncToken type.

# `i1`

# `i8`

# `i16`

# `i32`

# `i64`

# `i128`

# `i`

# `index`

calls `Beaver.MLIR.CAPI.mlirIndexTypeGet/1` to get Index type

# `index?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAIndex/1` to check if it is Index type.

# `integer`

# `integer?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAInteger/1` to check if it is Integer type.

# `llvm_array?`

calls `Beaver.MLIR.CAPI.mlirTypeIsALLVMArrayType/1` to check if it is LLVMArray type.

# `llvm_function?`

calls `Beaver.MLIR.CAPI.mlirTypeIsALLVMFunctionType/1` to check if it is LLVMFunction type.

# `llvm_pointer`

# `llvm_pointer?`

calls `Beaver.MLIR.CAPI.mlirTypeIsALLVMPointerType/1` to check if it is LLVMPointer type.

# `llvm_struct?`

calls `Beaver.MLIR.CAPI.mlirTypeIsALLVMStructType/1` to check if it is LLVMStruct type.

# `llvm_void`

calls `Beaver.MLIR.CAPI.mlirLLVMVoidTypeGet/1` to get LLVMVoid type

# `make`

# `memref`

# `memref!`

# `memref?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAMemRef/1` to check if it is MemRef type.

# `none`

calls `Beaver.MLIR.CAPI.mlirNoneTypeGet/1` to get None type

# `none?`

calls `Beaver.MLIR.CAPI.mlirTypeIsANone/1` to check if it is None type.

# `nvgpu_tensor_map_descriptor?`

calls `Beaver.MLIR.CAPI.mlirTypeIsANVGPUTensorMapDescriptorType/1` to check if it is NVGPUTensorMapDescriptor type.

# `opaque`

# `opaque?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAOpaque/1` to check if it is Opaque type.

# `pdl?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAPDLType/1` to check if it is PDL type.

# `pdl_attribute`

calls `Beaver.MLIR.CAPI.mlirPDLAttributeTypeGet/1` to get PDLAttribute type

# `pdl_attribute?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAPDLAttributeType/1` to check if it is PDLAttribute type.

# `pdl_operation`

calls `Beaver.MLIR.CAPI.mlirPDLOperationTypeGet/1` to get PDLOperation type

# `pdl_operation?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAPDLOperationType/1` to check if it is PDLOperation type.

# `pdl_range`

calls `Beaver.MLIR.CAPI.mlirPDLRangeTypeGet/1` to get PDLRange type

# `pdl_range?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAPDLRangeType/1` to check if it is PDLRange type.

# `pdl_type`

calls `Beaver.MLIR.CAPI.mlirPDLTypeTypeGet/1` to get PDLType type

# `pdl_type?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAPDLTypeType/1` to check if it is PDLType type.

# `pdl_value`

calls `Beaver.MLIR.CAPI.mlirPDLValueTypeGet/1` to get PDLValue type

# `pdl_value?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAPDLValueType/1` to check if it is PDLValue type.

# `quantized?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAQuantizedType/1` to check if it is Quantized type.

# `ranked_tensor`

# `ranked_tensor!`

# `ranked_tensor?`

calls `Beaver.MLIR.CAPI.mlirTypeIsARankedTensor/1` to check if it is RankedTensor type.

# `shaped?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAShaped/1` to check if it is Shaped type.

# `si1`

# `si8`

# `si16`

# `si32`

# `si64`

# `si128`

# `signed?`

calls `Beaver.MLIR.CAPI.mlirIntegerTypeIsSigned/1` to check if it is a signed integer.

# `signless?`

calls `Beaver.MLIR.CAPI.mlirIntegerTypeIsSignless/1` to check if it is a signless integer.

# `tensor?`

calls `Beaver.MLIR.CAPI.mlirTypeIsATensor/1` to check if it is Tensor type.

# `tf32`

calls `Beaver.MLIR.CAPI.mlirTF32TypeGet/1` to get TF32 type

# `tf32?`

calls `Beaver.MLIR.CAPI.mlirTypeIsATF32/1` to check if it is TF32 type.

# `transform_any_op`

calls `Beaver.MLIR.CAPI.mlirTransformAnyOpTypeGet/1` to get TransformAnyOp type

# `transform_any_op?`

calls `Beaver.MLIR.CAPI.mlirTypeIsATransformAnyOpType/1` to check if it is TransformAnyOp type.

# `transform_any_param`

calls `Beaver.MLIR.CAPI.mlirTransformAnyParamTypeGet/1` to get TransformAnyParam type

# `transform_any_param?`

calls `Beaver.MLIR.CAPI.mlirTypeIsATransformAnyParamType/1` to check if it is TransformAnyParam type.

# `transform_any_value`

calls `Beaver.MLIR.CAPI.mlirTransformAnyValueTypeGet/1` to get TransformAnyValue type

# `transform_any_value?`

calls `Beaver.MLIR.CAPI.mlirTypeIsATransformAnyValueType/1` to check if it is TransformAnyValue type.

# `transform_operation?`

calls `Beaver.MLIR.CAPI.mlirTypeIsATransformOperationType/1` to check if it is TransformOperation type.

# `transform_param?`

calls `Beaver.MLIR.CAPI.mlirTypeIsATransformParamType/1` to check if it is TransformParam type.

# `tuple`

Get a tuple type.

## Examples
    iex> ctx = MLIR.Context.create()
    iex> MLIR.Type.tuple([MLIR.Type.i32, MLIR.Type.i32], ctx: ctx) |> MLIR.to_string()
    "tuple<i32, i32>"
    iex> MLIR.Context.destroy(ctx)

# `tuple?`

calls `Beaver.MLIR.CAPI.mlirTypeIsATuple/1` to check if it is Tuple type.

# `ui1`

# `ui8`

# `ui16`

# `ui32`

# `ui64`

# `ui128`

# `uniform_quantized?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAUniformQuantizedType/1` to check if it is UniformQuantized type.

# `uniform_quantized_per_axis?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAUniformQuantizedPerAxisType/1` to check if it is UniformQuantizedPerAxis type.

# `uniform_quantized_sub_channel?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAUniformQuantizedSubChannelType/1` to check if it is UniformQuantizedSubChannel type.

# `unranked_memref`

# `unranked_memref!`

# `unranked_memref?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAUnrankedMemRef/1` to check if it is UnrankedMemRef type.

# `unranked_tensor`

# `unranked_tensor!`

# `unranked_tensor?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAUnrankedTensor/1` to check if it is UnrankedTensor type.

# `unsigned?`

calls `Beaver.MLIR.CAPI.mlirIntegerTypeIsUnsigned/1` to check if it is a unsigned integer.

# `vector`

Get a vector type creator.

## Examples
    iex> ctx = MLIR.Context.create()
    iex> MLIR.Type.vector!([1, 2, 3], MLIR.Type.i32(ctx: ctx)) |> MLIR.to_string()
    "vector<1x2x3xi32>"
    iex> MLIR.Context.destroy(ctx)

# `vector!`

# `vector?`

calls `Beaver.MLIR.CAPI.mlirTypeIsAVector/1` to check if it is Vector type.

# `width`

get the width of the int or float type