Create an object/Native demonstration: Difference between revisions

{{draft task}}

 

 

 

If the language supports '''Magic Methods''', then show how these work.

 

=={{header|D}}==

{{trans|Python}}

TV[TK] standard, current;

 

d.remove("a");

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

{{out}}

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

 

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:

 

3) In J, objects are always referenced, but all data is passed by value. This means that objects can never be passed to a function -- only a reference to an object (its name) can be passed. This means that objects exist only in the way things are named, in J. So for the most part, we do not call things "objects" in J, and this task has nothing to do with what are called "objects" in J. However, this does demonstrate how things are created in J -- you write their definition, and can use them and/or assign to names or inspect them or whatever else.

 

=={{header|JavaScript}}==

{{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|Kotlin}}==

 

fun main(args: Array<String>) {

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

println(map)

 

{{out}}

{A=65, B=66, C=67}

</pre>

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

{{trans|C sharp}}

Module CheckIt {

Class LockedHash {

}

module NoRemoveItem {

}

Public:

}

module Writeln {

while m {

Print Quote$(Eval$(m, m^));",";Eval(m),

Read val

if exist(.Vars, st$) then Return .Vars, st$:=val : Exit

}

module Remove (st$) {

}

Checkit

 

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

a[2] = "Native demonstration";

Example usage:

<pre>a[3] = 2

->Set::write: Tag a in a[1] is Protected. >>

</pre>

 

=={{header|Perl}}==

use Carp;

 

sub TIEHASH {

}

 

my $ref = shift;

tie(%$ref, __PACKAGE__, %$ref);

# 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|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))

#fenced-hash(("b" . 66) ("a" . 55))

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

 

=={{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

trying: unset dic

dic:1 one 2 two

 

=={{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