Associative array/Merging: Difference between revisions

{{trans|Python}}

V update = [‘price’ = ‘15.25’, ‘color’ = ‘red’, ‘year’ = ‘1974’]

result.update(update)

{{out}}

=={{header|Ada}}==

with Ada.Containers.Indefinite_Ordered_Maps;

New_Line;

{{out}}

<pre>Original:

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Uses the associative array implementations in [[ALGOL_68/prelude]].

# the modes allowed as associative array element values - change to suit #

);

e := NEXT c

{{out}}

<pre>

The method with AppleScript "records" is to concatenate them. The result is a third record containing the labels from both contributors, the values from the record to the left of the operator being kept where labels are shared. The bars with some of the labels below are to distinguish them as "user" labels from tokenised ones that are provided as standards for use by scriptable applications and scripting additions. However, merging records works with tokenised labels too.

set updateRecord to {price:15.25, |color|:"red", |year|:1974}

set mergedRecord to updateRecord & baseRecord

{{output}}

=={{header|Arturo}}==

newDetails: extend details #[price: 15.25 colour: 'red year: 1974]

{{out}}

=={{header|AutoHotkey}}==

Merged := {}

for k, v in base

Merged[k] := v

return Merged

update := {"price":15.25, "color":"red", "year":1974}

Merged := merge(base, update)

for k, v in Merged

result .= k " : " v "`n"

Outputs:<pre>color : red

name : Rocket Skates

=={{header|AWK}}==

# syntax: GAWK -f ASSOCIATIVE_ARRAY_MERGING.AWK

#

}

}

{{out}}

<pre>

=={{header|B4X}}==

Dim m2 As Map = CreateMap("price": 15.25, "color": "red", "year": 1974)

Dim merged As Map

Next

Next

=={{header|BaCon}}==

base$("name") = "Rocket Skates"

FOR x$ IN OBTAIN$(merge$)

PRINT x$, " : ", merge$(x$)

{{out}}

<pre>Base array

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

#include <string>

#include <map>

std::cout << "key: " << i.first << ", value: " << i.second << '\n';

return 0;

{{out}}

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

using System.Collections.Generic;

using System.Linq;

}

}

{{out}}

<pre>

=={{header|Clojure}}==

(defn update-map [base update]

(merge base update))

"color" "red"

"year" "1974"})

{{out}}

=={{header|Crystal}}==

update = { "price" => 15.25, "color" => "red", "year" => 1974 }

{{out}}

=={{header|Common Lisp}}==

In Common Lisp, the value of a key in an alist or a plist is defined as the first value in the list with a matching key or indicator. Thus, all that is necessary to implement this algorithm for either is the following:

(append list2 list1)

These implementations for alists and plists are more complicated, but avoid duplicate keys in the results:

(defun merge-alists (alist1 alist2)

(nconc

:do (setf (getf res key) val))

res))

=={{header|Dart}}==

main() {

var base = {

}

=={{header|Delphi}}==

{{libheader| System.Generics.Collections}}

{{Trans|C#}}

program Associative_arrayMerging;

end.

{{out}}

<pre>

=={{header|Elixir}}==

Elixir has a built-in hashmap type, called [https://hexdocs.pm/elixir/Map.html Map].

update = %{price: 15.25, color: "red", year: 1974}

result = Map.merge(base, update)

{{out}}

<pre>%{color: "red", name: "Rocket Skates", price: 15.25, year: 1974}</pre>

The above sample uses [https://hexdocs.pm/elixir/Atom.html atoms] as the key type. If strings are needed, the <code>base</code> map would look like this:

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

type N = |Price of float|Name of string|Year of int|Colour of string

let n=Map<string,N>[("name",Name("Rocket Skates"));("price",Price(12.75));("colour",Colour("yellow"))]

let ng=(Map.toList n)@(Map.toList g)|>Map.ofList

printfn "%A" ng

{{out}}

<pre>

The <code>assoc-union</code> word does this. <code>assoc-union!</code> is a variant that mutates the first associative array.

{{works with|Factor|0.99 2019-10-06}}

{ { "name" "Rocket Skates" } { "price" 12.75 } { "color" "yellow" } }

{ { "price" 15.25 } { "color" "red" } { "year" 1974 } }

{{out}}

<pre>

=={{header|Go}}==

import "fmt"

result := merge(base, update)

fmt.Println(result)

{{out}}

There are various approaches, all of which would be strictly typed.<br>

For example, if we want to treat the input and output records as all sharing the same type:

{ name :: Maybe String

, price :: Maybe Float

itemFromMerge

(Item (Just "Rocket Skates") (Just 12.75) (Just "yellow") Nothing)

{{Out}}

<pre>Item {name = Just "Rocket Skates", price = Just 15.25, color = Just "red", year = Just 1974}</pre>

=={{header|Icon}} and {{header|Unicon}}==

local base, update, master, f, k

write(k, " = ", master[k])

}

{{out}}

=={{header|J}}==

merge=: ,. NB. use: update merge original

compress=: #"1~ ~:@:keys

get=: [: > ((i.~ keys)~ <)~ { values@:] NB. key get (associative array)

pair=: [: |: <;._2;._2

Exercise the definitions. Interactive J prompts with 3 space indentation.

<pre>

=={{header|Java}}==

class MergeMaps {

System.out.println(result);

}

{{output}}

<pre>{name=Rocket Skates, color=red, year=1974, price=15.25}</pre>

=={{header|JavaScript}}==

'use strict';

null, 2

))

{{Out}}

<pre>{

=={{header|Kotlin}}==

fun main() {

val base = HashMap<String,String>()

println("merged: $merged")

}

{{Output}}

<pre>

=={{header|Lua}}==

update = {price=15.25, color="red", year=1974}

for key,val in pairs(result) do

print(string.format("%s: %s", key, val))

{{output}}

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

a2 = <|"price" -> 15.25, "color" -> "red", "year" -> 1974|>;

{{out}}

<pre><|"name" -> "Rocket Skates", "price" -> 15.25, "color" -> "red", "year" -> 1974|></pre>

=={{header|MiniScript}}==

MiniScript supports merging maps with the + operator.

update = {"price":15.25, "color":"red", "year":1974}

result = base + update

{{output}}

=={{header|Nim}}==

let t1 = {"name": "Rocket Skates", "price": "12.75", "color": "yellow"}.toTable

t3[key] = value

{{out}}

=={{header|Objective-C}}==

{{works with|Cocoa}}

int main(void) {

}

return 0;

{{output}}

<pre>{

Helper code for all 3 versions:

type ty =

| TFloat of float

Printf.printf "%s: %s\n" key (string_of_ty el)

;;

Association list : naive and functional approach.

let l1 : assoc list = [

("name", TString "Rocket Skates");

let l' = merge_assoc_list l1 l2 ;;

Binary tree/Map functor : proper functional approach.

{{works with|OCaml|above 4.03 for union function}}

module StringMap = Map.Make(String) ;;

print_map m' ;;

Hash table : imperative/mutable approach.

(* Updates the base table with the bindings from add *)

let hash_merge (base : (string, ty) Hashtbl.t) (add : (string, ty) Hashtbl.t) : unit =

print_hashtbl h1 ;;

=={{header|Ol}}==

Since version 3.1.1 function `ff-union` changed from `(ff-union a1 a2 collide)` to `(ff-union collide a1 a2 ...)`!

(define a1 {

'name "Rocket Skates"

(define (collide a b) b) ; will use new key value

(print "merged a1 a2: " (ff-union collide a1 a2))

{{Out}}

<pre>

=={{header|Perl}}==

use warnings;

$merge{$_} = [$base{$_}] for keys %base;

push @{$merge{$_}}, $more{$_} for keys %more;

{{output}}

<pre>Update

=={{header|Phix}}==

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

<span style="color: #004080;">integer</span> <span style="color: #000000;">d1</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">new_dict</span><span style="color: #0000FF;">({{</span><span style="color: #008000;">"name"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Rocket Skates"</span><span style="color: #0000FF;">},{</span><span style="color: #008000;">"price"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">12.75</span><span style="color: #0000FF;">},{</span><span style="color: #008000;">"color"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"yellow"</span><span style="color: #0000FF;">}}),</span>

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">/</span><span style="color: #000000;">map</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

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

{{out}}

<pre>

=={{header|Phixmonti}}==

def scand /# dict key -- dict n #/

pstack

=={{header|PHP}}==

$base = array("name" => "Rocket Skates", "price" => 12.75, "color" => "yellow");

$update = array("price" => 15.25, "color" => "red", "year" => 1974);

$result = $update + $base; // Notice that the order is reversed

print_r($result);

{{output}}

<pre>Array

Alternative:

$base = array("name" => "Rocket Skates", "price" => 12.75, "color" => "yellow");

$update = array("price" => 15.25, "color" => "red", "year" => 1974);

$result = array_merge($base, $update);

print_r($result);

{{output}}

<pre>Array

=={{header|PureBasic}}==

NewMap m2.s()

NewMap m3.s()

ForEach m3()

Debug MapKey(m3())+" : "+m3()

{{out}}

<pre>price : 15.25

As of Python 3.5, this can be solved with the dictionary unpacking operator.

{{works with|Python|3.5+}}

update = {"price":15.25, "color":"red", "year":1974}

result = {**base, **update}

{{output}}

<pre>{'name': 'Rocket Skates', 'price': 15.25, 'color': 'red', 'year': 1974}</pre>

;Alternative:

update = {"price":15.25, "color":"red", "year":1974}

result.update(update)

{{output}}

<pre>{'name': 'Rocket Skates', 'price': 15.25, 'color': 'red', 'year': 1974}</pre>

;New alternative using '|'

Type "help", "copyright", "credits" or "license()" for more information.

>>> base = {"name":"Rocket Skates", "price":12.75, "color":"yellow"}

>>> result

{'name': 'Rocket Skates', 'price': 15.25, 'color': 'red', 'year': 1974}

=={{header|Racket}}==

(require racket/hash)

(hash-union base-data update-data #:combine (λ (a b) b)))

{{out}}

I must say I somewhat disagree with the terminology. The requested operation is an update not a merge. Demonstrate both an update and a merge. Associative arrays are commonly called hashes in Raku.

say my %base = :name('Rocket Skates'), :price<12.75>, :color<yellow>;

say my %update = :price<15.25>, :color<red>, :year<1974>;

# Demonstrate unmutated hashes

{{out}}

<pre>{color => yellow, name => Rocket Skates, price => 12.75}

The double quotes that surround the string (character) items (as shown in the task's preamble) weren't included for this presentation,

<br>although they could easily be added.

$.= /*define default value(s) for arrays. */

@.wAAn= 21; @.wKey= 7; @.wVal= 7 /*max widths of: AAname, keys, values.*/

say center(AAn, @.wAAn) right(key, @.wKey) $.AAn.key /*show some information.*/

end /*j*/

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

<pre>

=={{header|Ring}}==

load "stdlib.ring"

see list1[n][1] + " = " + list1[n][2] + nl

next

Output:

<pre>

=={{header|Ruby}}==

update = {"price" => 15.25, "color" => "red", "year" => 1974}

result = base.merge(update)

{{output}}

<pre>{"name"=>"Rocket Skates", "price"=>15.25, "color"=>"red", "year"=>1974}</pre>

=={{header|Rust}}==

fn main() {

println!("{:#?}", original);

}

{{output}}

<pre>{

in an alist. Hence, a merge may be implemented by simply appending the update alist to the

front of the base alist. The downside is this leaves a bunch of useless junk in the alist.

; (The extra '() is so that append doesn't co-opt the second list.)

(define append-alists

(unless (null? keys)

(printf "~s -> ~s~%" (car keys) (cdr (assoc (car keys) merged)))

{{out}}

<pre>

This is more true to the intent of the Task. It generates a new alist with only the key/value

pairs needed.

; Returns a new list; the argument lists are not modified.

(define merge-alists

(unless (null? keys)

(printf "~s -> ~s~%" (car keys) (cdr (assoc (car keys) merged)))

{{out}}

<pre>

=={{header|SenseTalk}}==

In addition to setting individual property values, SenseTalk includes 5 built-in operations for modifying property lists, to: add properties, replace properties, remove properties, retain properties, and rename properties. The operation to replace properties is needed for this task.

set update to {price:15.25, color:"red", year:1974}

replace properties of update in base

put "Base after update: " & base

{{out}}

<pre>

=={{header|Smalltalk}}==

'name'-> 'Rocket Skates' .

'price' -> 12.75 .

declareAllFrom:update.

{{out}}

<pre>Dictionary(name->Rocket Skates price->15.25 year->1974 color->red)</pre>

=={{header|Swift}}==

{{works with|Swift|5+}}

let update : [String: Any] = ["price": 15.25, "color": "red", "year": 1974]

let result = base.merging(update) { (_, new) in new }

{{output}}

<pre>["price": 15.25, "name": "Rocket Skates", "color": "red", "year": 1974]</pre>

=={{header|Tcl}}==

set dict2 [dict create price 15.25 color red year 1974]

dict for {key val} [dict merge $dict1 $dict2] {

puts "$key: $val"

{{output}}

<pre>name: Rocket Skates

3 ways to do this tasks :

First : With Arrays + Type

Private Type Associative

Key As String

Next i

Debug.Print "-----------------------------"

Second way (simply) : with the Scripting Dictionary Object :

Dim Base As Object, Update As Object, Merged As Object, K As Variant

'INIT VARIABLE

Debug.Print K, Merged(K)

Next K

And the Third : With a Class Module (named ClassArrayAssociative)

The Class Module code:

Private mKey As String

Value = V

Key = K

The Module code :

Dim Base(2) As New ClassArrayAssociative, Up(2) As New ClassArrayAssociative

ReDim Result(UBound(Base)) As New ClassArrayAssociative

Next i

Debug.Print "-----------------------------"

{{out}}

<pre>

=={{header|VBScript}}==

set d1=createobject("Scripting.Dictionary")

d1.add "name", "Rocket Skates"

wscript.echo k3 & vbtab & d3(k3)

next

{{out}}

<pre>

=={{header|Wren}}==

var m3 = {}

for (key in m1.keys) m3[key] = m1[key]

var update = { "price": 15.25, "color": "red", "year": 1974 }

var merged = mergeMaps.call(base, update)

{{out}}

=={{header|Vlang}}==

type Assoc = map[string]Generic

println('$k: $v')

}

{{out}}

<pre>

=={{header|Wren}}==

var m3 = {}

for (key in m1.keys) m3[key] = m1[key]

var update = { "price": 15.25, "color": "red", "year": 1974 }

var merged = mergeMaps.call(base, update)

{{out}}

=={{header|zkl}}==

"name", "Rocket Skates",

"price", 12.75,

update.pump( new:=base.copy() );

{{out}}

<pre>