# Reflect
{% hint style="info" %}
You can easily import all the functions from the `reflect` registry by including the following import statement in your code
```go
import "github.com/go-sprout/sprout/registry/reflect"
```
{% endhint %}
### typeIs
The function compares the type of the provided value (`src`) to a specified target type string (`target`). It returns `true` if the type of `src` matches the target type.
Name
Value
Signature
TypeIs(target string, src any) bool
{% tabs %}
{% tab title="Template Example" %}
```go
{{ 42 | typeIs "int" }} // Output: true
```
{% endtab %}
{% endtabs %}
### typeIsLike
The function compares the type of the provided value (`src`) to a target type string (`target`), with an option for a wildcard `*` prefix (pointer). It returns `true` if `src` matches `target` or `*target`, which is useful for checking if a variable is of a specific type or a pointer to that type.
Name
Value
Signature
TypeIsLike(target string, src any) bool
{% tabs %}
{% tab title="Template Example" %}
```go
{{ 42 | typeIsLike "*int" }} // Output: false
```
{% endtab %}
{% endtabs %}
### typeOf
The function returns the type of the provided value (`src`) as a string, giving you a textual representation of its data type.
Name
Value
Signature
TypeOf(src any) string
{% tabs %}
{% tab title="Template Example" %}
```go
{{ 42 | typeOf }} // Output: "int"
```
{% endtab %}
{% endtabs %}
### kindIs
The function compares the kind (category) of a given value (`src`) to a target kind string (`target`). It returns `true` if the kind of `src` matches the specified target kind.
Name
Value
Signature
KindIs(target string, src any) (bool, error)
{% tabs %}
{% tab title="Template Example" %}
```go
{{ 42 | kindIs "int" }} // Output: true
{{ nil | kindIs "int" }} // Error
```
{% endtab %}
{% endtabs %}
### kindOf
The function returns the kind (category) of the provided value (`src`) as a string, giving a general classification like "int," "struct," or "slice."
Name
Value
Signature
KindOf(src any) (string, error)
{% tabs %}
{% tab title="Template Example" %}
```go
{{ 42 | kindOf }} // Output: "int"
{{ nil | kindOf }} // Error
```
{% endtab %}
{% endtabs %}
### hasField
The function checks the presence of a field with the specified name (`name`) in the provided struct (`src`). It returns `true` if the field exists.
Name
Value
Signature
HasField(name string, src any) (bool, error)
{% tabs %}
{% tab title="Template Example" %}
Assuming Struct has defined as : `type Struct struct { V string }`
```go
{{ hasField "V" .Struct }} // Output: true
{{ hasField "someNonExistingField" .Struct }} // Output: false
{{ .Struct | hasField "V" }} // Output: true
{{ .Struct | hasField "someNonExistingField" }} // Output: false
```
{% endtab %}
{% endtabs %}
### deepEqual
The function checks if two variables, `x` and `y`, are deeply equal by comparing their values and structures using `reflect.DeepEqual`.
Name
Value
Signature
DeepEqual(x, y any) bool
{% tabs %}
{% tab title="Template Example" %}
```go
{{ .Struct | deepEqual .Struct }} // Output: true
{{ .Struct | deepEqual .SecondStruct }} // Output: false
```
{% endtab %}
{% endtabs %}
### deepCopy
The function performs a deep copy of the provided `element`, creating an exact duplicate of its structure and data. It uses `MustDeepCopy` internally to manage the copy process and handle any potential errors. This use the [copystructure package](https://github.com/mitchellh/copystructure) internally.
Name
Value
Signature
DeepCopy(element any) (any, error)
{% tabs %}
{% tab title="Template Example" %}
```go
{{ dict "name" "John" | deepCopy }} // Output: map[name:John]
{{ nil | deepCopy }} // Error
```
{% endtab %}
{% endtabs %}
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.atom.codes/sprout/registries/reflect.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.