Type detection: Difference between revisions

If not practical, show how the caller would coerce a type that can be passed to the library function.

<br><br>

 

=={{header|ATS}}==

===Using garbage collection and '''datatype'''===

 

datatype source_t =

print_text (source_t_string "This\nis a\ntext.\n");

print_text (source_t_FILEref f)

 

{{out}}

In this implementation, '''print_text''' consumes its argument; the argument’s value cannot be used again. However, the object wrapped in the '''source_vt''' might be reusable.

 

 

dataviewtype source_vt =

| ~ Some_vt f => print_text (source_vt_FILEref f)

| ~ None_vt () => fprintln! (stderr_ref, "Failed to open the file.")

{{out}}

$ patscc -DATS_MEMALLOC_LIBC type_detection-postiats-2.dats && ./a.out

 

=={{header|AWK}}==

# syntax: TAWK -f TYPE_DETECTION.AWK

# uses Thompson Automation's TAWK 5.0c

exit(0)

}

{{out}}

<pre>

=={{header|C}}==

The closest C comes to meeting this task, short of building it into the compiler or accessing memory segments via pointers, which is not guaranteed to be portable, is the ctype.h header file. It is part of the C Standard Library and provides 11 methods for detecting the type of a character, out of which the following 7 called in the wrapper function below can be called to be unique. The function accepts a string, but it actually checks the first character. An if ladder is used instead of if-else so that all function calls which return a non-zero value for the character are satisfied and the information is printed.

#include<stdio.h>

#include<ctype.h>

return 0;

}

Output, shown for multiple inputs, as well as single ones:

<pre>

 

===Dispatch by ''tagged union''===

#include <stdbool.h>

#include <assert.h>

source.value.input_file = fopen ("type_detection-c.c", "r");

print_text (source);

{{out}}

$ cc type_detection-c.c && ./a.out

 

=={{header|C sharp|C#}}==

 

namespace TypeDetection {

}

}

{{out}}

<pre>The type of '5' is System.Int32

=={{header|C++}}==

{{trans|D}}

 

template <typename T>

std::cout << typeString(S{}) << '\n';

std::cout << typeString(nullptr) << '\n';

{{out}}

<pre>int

 

=={{header|Crystal}}==

puts "Compile-time type of #{x} is #{typeof(x)}"

puts " Actual runtime type is #{x.class}" if x.class != typeof(x)

print_type({a: 1, b: 2})

print_type ->(x : Int32){ x+2 > 0 }

{{out}}

<pre>Compile-time type of 123 is Int32

 

=={{header|D}}==

 

auto typeString(T)(T _) {

writeln(typeString(S()));

writeln(typeString(null));

 

{{out}}

 

=={{header|F_Sharp|F#}}==

printfn "%A" (3.14.GetType())

let inline fN g=g.GetType()|>string

printfn "%s" (fN "Nigel")

printfn "%s" (fN 23)

{{out}}

<pre>

=={{header|Factor}}==

Using dynamic dispatch:

strings ;

IN: rosetta-code.type-detection

{ 1 2 3 4 5 } myprint

123 myprint

{{out}}

<pre>

Below I use ‘class(*)’. The ‘print_text’ subroutine is used to print a string, an array of strings, and an input file.

 

implicit none

 

end subroutine print_text

 

 

{{out}}

(To use this mechanism in a library, one would want to use modules. Nevertheless, the program below illustrates the principle more simply.)

 

 

implicit none

end subroutine print_text_file_unit

 

{{out}}

$ gfortran type_detection-fortran-2.f90 && ./a.out

 

end program type_detection_demo</pre>

 

=={{header|Go}}==

Note that Go doesn't really have a character type. A single quoted character (such as 'd') is by default a ''rune'' (or 32 bit integer) literal representing its Unicode code-point.

 

import "fmt"

showType(value)

}

 

{{out}}

{{trans|Icon}}

 

print_text("This\nis a\ntext.\n")

print_text(file("type_detection-goaldi.gd"))

file : while write(read(source))

}

 

{{out}}

See also [[#ObjectIcon|ObjectIcon]] and [[#Goaldi|Goaldi]].

 

print_text("This\nis\na text.\n")

print_text(open("type_detection-icon.icn"))

"file" : while write(read(source))

}

{{out}}

$ icont -u -s type_detection-icon.icn && ./type_detection-icon

Presumably this satisfies the task requirements...

 

one

echo 1

 

=={{header|Java}}==

{{trans|Kotlin}}

private static void showType(Object a) {

if (a instanceof Integer) {

showType(true);

}

{{out}}

<pre>'5' is an integer

<code>typeof</code> function, and the function <code>isa</code> tests

whether an object is of that type.

 

julia> a = 1

true

 

 

=={{header|OASYS Assembler}}==

 

; The following method checks if a global variable or property is an

; object type. Does not work with locals and arguments.

/>1RF ; It is clear

:>0RF ; It is not clear

 

=={{header|Kotlin}}==

fun showType(a: Any) = when (a) {

is Int -> println("'$a' is an integer")

showType('d')

showType(true)

 

{{out}}

 

=={{header|Lua}}==

local t = type(v)

if t == "number" then

end

 

{{out}}

<pre>The value 42 is of type number

===Using a generic procedure===

All is done at compile time. The generated code depends on the type of the parameter. We accept here any type, but only provide code to display text from a string and from a file and we emit an error for the other types.

when T is string:

echo source

writeText("Hello world!")

writeText(stdin)

 

===Using variant objects===

We define a type “Source” which contains a discriminator (tag) which is used to define branches. The code to display the text contains a test on the tag. The only types allowed are those for which a tag value exists. Here, we defined two possible values: “kString” and “kFile”. The “type detection” is done at runtime, but these are not actual types but tag values.

 

type Source = object

 

s1.writeText()

 

=={{header|ObjectIcon}}==

{{trans|Icon}}

 

procedure main()

"object" : while write(source.read())

}

{{out}}

$ oit -s type_detection-oi.icn && ./type_detection-oi

Pascal has a plethora of dialects, and so I have tried to be as close to ''Algorithms + Data Structures = Programs'' (Wirth) style as I could figure out how, when using the Free Pascal Compiler.

 

type

sourcetype = record case kind : (builtintext, filetext) of

printtext (source)

end

 

{{out}}

The function <code>ref</code> takes a reference to a variable, via '\', and returns the type. Some of the more common are shown here.

In the cases where the value in question is already a reference (<code>$regex</code> and <code>$subref</code>) the '\' is not used.

@array = (1, 2);

%hash = ('a' => 1);

printf $fmt, '$regex', ref( $regex);

printf $fmt, '$reference', ref(\$reference);

{{out}}

<pre>$scalar is type: SCALAR

{{libheader|Phix/basics}}

Phix builtin type tests are: integer(), atom(), string(), sequence(), and object(). The latter returns true unless arg is unassigned, also notice that showtype never even attempts to set t to "object", since it is guaranteed to be one of the other four.

<span style="color: #008080;">procedure</span> <span style="color: #000000;">showtype</span><span style="color: #0000FF;">(</span><span style="color: #004080;">object</span> <span style="color: #000000;">o</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">string</span> <span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span><span style="color: #0000FF;">(</span><span style="color: #000000;">o</span><span style="color: #0000FF;">)?</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span><span style="color: #0000FF;">(</span><span style="color: #000000;">o</span><span style="color: #0000FF;">)?</span><span style="color: #008000;">"integer"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"atom"</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">showtype</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"string"</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">showtype</span><span style="color: #0000FF;">({</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7.5</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"string"</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

=={{header|PowerShell}}==

In PowerShell everything is an object and all objects have the GetType() method:

[string]$str = "123"

$str.GetType()

{{Out}}

<pre>

True True String System.Object

</pre>

[int]$int = $str -as [int]

$int.GetType()

{{Out}}

<pre>

http://docs.racket-lang.org/ts-reference/type-ref.html

 

 

(require racket/undefined)

(td ,(string-join (->type-names v) ", "))))

test-values)))))

 

{{out}}

Raku is a dynamic language that has gradual, duck typing. It provides introspection methods through its comprehensive MOP (Meta Object Protocol) making it easy to do type detection, subroutine signatures and multi-dispatch. Raku types have two general flavors: content types and container types. Different container types have varying restrictions on what sort of content they can contain and in return provide specialized methods to operate on those contents. Content types give the compiler hints on how to best handle the information, what storage requirements it may have, what operators will work with it, etc.

 

 

 

# some content types

my my-type $object;

 

 

{{out}}

<br>strings can be classified by having certain characteristics, &nbsp; or in other words, ''types''.

<br>Characteristics of these &nbsp; ''types'' &nbsp; can overlap.

signal on noValue /*trap for undefined REXX variables. */

y= 1938 ; call showType y /*╔═══════════════════════════════════╗*/

if datatype(x, 'S') then say @ "a REXX symbol."

say copies('▒', 50) /*a fence that is used as a separator. */

{{out|output|text=&nbsp; when using the internal default data:}}

<pre>

 

=={{header|Ring}}==

# Project : Type detection

 

see "7.5 -> " + type(7.5) + nl

see "d -> " + type('d') + nl

Output:

<pre>

The compiler will require that all possible values are handled, even if it's as simple as a fallthrough <code>_ => unreachable!()</code> which causes the program to die in a memory-safe way.

 

Int(i64),

UInt(u64),

}

}

 

Output:

As Rust allows you to implement your own traits on other people's types, this can be used to implement type detection.

 

use std::fs::File;

use std::io::{self,prelude::*};

 

Ok(())

 

Output:

Finally, while it's more limited than it appears, Rust does have some small degree of support for type introspection.

 

 

pub fn is_string(thing: &dyn Any) {

is_string(&"Hello, World!");

is_string(&5u16);

 

Output:

 

=={{header|Scala}}==

def showType(a: Any) = a match {

case a: Int => println(s"'$a' is an integer")

println(s"\nSuccessfully completed without errors. [total ${scala.compat.Platform.currentTime - executionStart} ms]")

 

 

=={{header|Scheme}}==

(cond ((string? source)

;; The source is a string.

(print-text '("Print\n" "a list\n" "of strings.\n"))

 

 

{{out}}

=={{header|Smalltalk}}==

Just send class to any object and ask the class for its name...

e'arg is of type {anyObject class name} and prints itself as: "{anyObject printString}"' printCR

].

typeOf value: (SmallInteger >> #+).

[ 1 / 0 ] on:Error do:[:ex | typeOf value: ex ]. "catch the exception"

{{out}}

<pre>arg is of type SmallInteger and prints itself as: "1234"

=={{header|VBA}}==

VBA has a built-in function TypeName (VarType returns a number), which can also recognize arrays.

Dim c(1) As Currency

Dim d(1) As Double

Debug.Print TypeName(CStr(1))

Debug.Print TypeName(Worksheets(1))

<pre>Application

Boolean

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|9.0+}}

 

Sub Main()

 

End Module

 

{{out}}

</pre>

 

println('The type of $a is ${typeof(a).name}')

}

show_type(`s`)

show_type([0x32,0x22])

 

{{out}}

The type of [50, 34] is []int

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

 

var showType = Fn.new { |obj|

 

var a = [4, 3.728, [1, 2], { 1: "first" }, true, null, 1..6, "Rosetta"]

 

{{out}}

 

=={{header|Z80 Assembly}}==

 

org &8000

byte 1,&46

TestBCD:

 

{{out}}

 

=={{header|zkl}}==

if (data_or_fileName.isType(String)) // == .isType("")

data_or_fileName=File(data_or_fileName,"rb").read(); //-->Data

doTheActualTextProcessing(text);

}

If an int is passed in, (123).text --> "123", other objects might throw an exception.

 

How to use:

processText(Data(Void,"This is some text"));

// fake up a class that holds a string:

cs:=class{ var text }; cs.text="this is more text";

{{out}}

<pre>