Create an object/Native demonstration: Difference between revisions

 

=={{header|BASIC256}}==

mapa["A"] = 65

mapa["B"] = 66

print valor

print mapa[valor]

{{out}}

<pre>A

 

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

#include <map>

#include <utility>

}

}

{{out}}

<pre>Map intialized with values

=={{header|D}}==

{{trans|Python}}

TV[TK] standard, current;

 

d.remove("a");

d.writeln; // ["a":1, "b":66]

{{out}}

<pre>["a":1, "b":2]

=={{header|FreeBASIC}}==

FB doesn't have Dict natively, but we can implement them via Type

m1 As String*1

m2 As Integer

Print mapOf(i).m1

Print mapOf(i).m2

{{out}}

<pre>A

 

First create a sub-directory, romap, of the project directory and place the following package in it:

 

type Romap struct{ imap map[byte]int }

rom.imap[key] = 0 // default value of int

}

 

This package can now be imported and used within the main package as follows:

 

import (

i, _ = rom.Get('C')

fmt.Println("'C' now maps to", i)

 

{{out}}

Given a list of keys and an associated list of values, the idiomatic way of expressing this concept in J would be:

 

 

For example:

 

lookup ;:'a test'

 

Notes:

Java supports unmodifiable maps, sets, lists, and other more specialized unmodifiable collections. In this example, we have a unmodifiable map. We first create an ordinary map, modify as needed, then call the <code>Collections.unmodifiableMap</code>. We can subsequently read the map, but modification is not permitted. The returned map will subsequently throw a <code>UnsupportedOperationException</code> exception if a mutation operator is called. Several are demonstrated below.

 

import java.util.Collections;

import java.util.HashMap;

}

 

{out}}

{{works with|JavaScript|1.7}}

 

 

function FixedKeyDict(obj)

return "FixedKeyDict{" + s + "}" ;

} ;

 

Test run:

 

const BR = "<BR>\n"

 

pl("error test : " + e.message) ;

}

 

output :

 

=={{header|jq}}==

 

jq objects, however, are really just values: they are immutable, and cannot be "deleted" any more than the number 1 can be deleted.

 

=={{header|Julia}}==

using BackedUpImmutable

 

@test fibr["a"] == 0

end

All tests pass.

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

val map = mapOf('A' to 65, 'B' to 66, 'C' to 67)

println(map)

 

{{out}}

=={{header|M2000 Interpreter}}==

{{trans|C sharp}}

Module CheckIt {

Class LockedHash {

}

Checkit

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

a[2] = "Native demonstration";

Example usage:

<pre>a[3] = 2

=={{header|Nim}}==

We leverage native stdlib table as our own object by implementing limited actual native table functionalities.

 

type

 

main()

{{output}}

<pre>

 

=={{header|Perl}}==

use parent Tie::Hash;

use Carp;

# add a new key x: will die

eval { $h{x} = 1 };

b => 4

c => 5

operation error: Can't add key x at test.pl line 14

LockedHash::STORE('LockedHash=HASH(0x8cebe14)', 'x', 1) called at test.pl line 66

 

=={{header|Phix}}==

There is no native "read-only" setting on phix dictionaries, so the following wraps a pair of them to

provide the requested functionality.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">enum</span> <span style="color: #000000;">STD</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">CUR</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

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

 

=={{header|Python}}==

from collections import UserDict

import copy

raise KeyError

else:

 

=={{header|Racket}}==

 

Implementation of functions that handle fenced-hash:

;(struct fenced-hash (actual original) ...)

 

;private custom-write ;mode is ignored

(write-string "#fenced-hash" port)

 

Definition of the actual structure and a “public” creator:

#:extra-constructor-name *fenced-hash ;private constructor

#:omit-define-syntaxes ;not sure this is a good idea

(define (fenced-hash . args) ; public constructor

(define original (apply hash args))

 

'''Example:''' Use the fenced-hash functions:

 

(displayln d)

(displayln d)

(fenced-hash-remove! d "a")

{{out}}

<pre>#fenced-hash(("b" . 2) ("a" . 1))

 

'''Example (continued):''' Use the same object as a dict. The dict-clear! method is not defined, so we must call fenced-hash-clear! instead.

(displayln d)

(dict-set! d "a" 55)

(displayln d)

(dict-remove! d "a")

{{out}}

<pre>#fenced-hash(("b" . 2) ("a" . 1))

{{Works with|rakudo|2016.08}}

Here we use delegation to handle all the normal hash methods that we don't need to override to define our new class.

has $.hash handles *;

method new(*@args) { self.bless: hash => Hash.new: @args }

say $fh<c>; # Nil

$fh<c> = 43; # error

{{out}}

<pre>(1 2)

By defining [http://design.raku.org/S12.html#FALLBACK_methods FALLBACK] any class can handle undefined method calls. Since any class inherits plenty of methods from <tt>Any</tt> our magic object will be more of a novice conjurer then a master wizard proper.

 

has %.hash;

multi method FALLBACK($name, |c) is rw { # this will eat any extra parameters

$magic.foo = 10;

say $magic.foo;

 

{{output}}

 

=={{header|Ring}}==

# Project : Create an object/Native demonstration

 

map["C"] = 67

see map + nl

Output:

<pre>

=={{header|Ruby}}==

{{works with|Ruby|1.9}}

# One may change its values, but not its keys. Any attempt to insert

# a new key raises KeyError. One may delete a key, but this only

keys.map {|key| self[key]}

end

 

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/OuVZ3bT/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/qW5qzmdKSZSyAbZEqDROoA Scastie (remote JVM)].

val map = Map('A' -> 65, 'B' -> 66, 'C' -> 67)

 

println(map)

 

=={{header|Tcl}}==

This solution uses a dict(ionary), so requires Tcl 8.5 or better. Variable traces are used to detect write or unset access to such a protected variable, restore it to the backup value at protection time, and throw an exception

 

upvar 1 $_var var

trace add variable var {write unset} [list protect0 $var]

puts "trying: $cmd"

if [catch {uplevel 1 $cmd} msg] {puts $msg}

Testing:

dict set dic 1 one

 

=={{header|Wren}}==

construct new(map) {

// copy the map so it cannot be mutated from the original reference

System.print(fsm.values.toList)

for (me in fsm) System.print([me.key, me.value])

 

{{out}}

=={{header|zkl}}==

zkl has two dictionary objects: SD, a small dictionary that is created immutable and the "regular" dictionary has has a makeReadOnly method. They both behave the same when locked down.

d.keys; //-->L("one","two")

d["one"]; //-->1

d.add("three",3); // error thrown