langref.org - python, fsharp, fantom, groovy ...

View Category

Maps

Declaration

Define an empty map

python

map = {}

fsharp

let map = Map.empty

let map = new Generic.Dictionary<string, string>()

let map = new Hashtable()

fantom

map := [:]

groovy

def map = [:]

Map map = new HashMap();

haskell

import qualified Data.Map as M

emptyMap = M.empty

Define an unmodifiable empty map

python

import collections
EmptyDict = collections.namedtuple("EmptyDict", "")
e = EmptyDict()

fsharp

// Most native fsharp data structures are immutable - updating a 'map' sees a modified copy created
let map = Map.empty

fantom

map := [:].ro

groovy

empty = Collections.EMPTY_MAP

map = [:].asImmutable()

def empty = MapUtils.EMPTY_SORTED_MAP

def empty = ImmutableMap.of()

haskell

import qualified Data.Map as Map

output :: Map.Map k v
output = Map.empty

Define an initial map

Define the map {circle:1, triangle:3, square:4}

python

shapes = {'circle': 1, 'square': 4, 'triangle': 2}

fsharp

let shapes = Map.ofList [("circle", 1); ("triangle", 3); ("square", 4)]

let shapes = Map.empty.Add("circle", 1).Add("triangle", 3).Add("square", 4)

let shapes = new Generic.Dictionary<string, int>()
shapes.Add("circle", 1)
shapes.Add("triangle", 3)
shapes.Add("square", 4)

let shapes = Map [("circle", 1); ("triangle", 3); ("square", 4)]

fantom

map := ["circle":1, "triangle":2, "square":4]

groovy

shapes = [circle:1, triangle:3, square:4]

// if you require a specific type of map ...
LinkedHashMap shapes1 = [circle:1, triangle:3, square:4]
Properties shapes2 = [circle:1, triangle:3, square:4]
TreeMap shapes3 = [circle:1, triangle:3, square:4]
shapes4 = [circle:1, triangle:3, square:4] as ConcurrentHashMap // as variation

haskell

import qualified Data.Map as M

initialMap = M.fromList [("circle", 1), ("triangle", 3), ("square", 4)]

Access

Check if a key exists in a map

Given a map pets {joe:cat,mary:turtle,bill:canary} print "ok" if an pet exists for "mary"

python

pets = dict(joe='cat', mary='turtle', bill='canary')
if ("mary" in pets) print "ok"

fsharp

if (Map.mem "mary" pets) then printfn "ok"

if pets.ContainsKey("mary") then printfn "ok"

fantom

map := ["joe":"cat", "mary":"turtle", "bill":"canary"]
if (map.containsKey("mary")) echo("ok")

groovy

pets = [joe:'cat', mary:'turtle', bill:'canary']
if(pets.containsKey('mary')) println 'ok'

pets = [joe:'cat', mary:'turtle', bill:'canary']
if(pets.mary) println 'ok'

haskell

import qualified Data.Map as M
import Control.Monad (when)

pets = M.fromList [("joe", "cat"), ("mary", "turtle"), ("bill", "canary")]

checkMary = when (M.member "mary" pets) (print "ok")

Retrieve a value from a map

Given a map pets {joe:cat,mary:turtle,bill:canary} print the pet for "joe" ("cat")

python

print pets['joe']

fsharp

if (Map.mem "joe" pets) then printfn "%s" (Map.find "joe" pets)

if (pets |> Map.exists (fun key _ -> key = "joe")) then printfn "%s" (Map.find "joe" pets)

let key = "joe"
match (pets |> Map.tryfind key) with
| Some(value) -> printfn "%s" value
| None -> printfn "Key %s not found" key

if pets.ContainsKey("joe") then printfn "%s" pets.["joe"]

if pets.ContainsKey("joe") then printfn "%s" (pets.["joe"] :?> string)

fantom

map := ["joe":"cat", "mary":"turtle", "bill":"canary"]
pet := map["joe"]
echo("pet=$pet")

groovy

pets = [joe:'cat', mary:'turtle', bill:'canary']
assert pets['joe'] == 'cat'

assert pets.joe == 'cat'

haskell

import qualified Data.Map as M

pets = M.fromList [("joe", "cat"), ("mary", "turtle"), ("bill", "canary")]
retrieve = print $ M.findWithDefault "Not found" "joe" pets

Add an entry to a map

Given an empty pets map, add the mapping from "rob" to "dog"

python

pets['rob'] = 'dog'

fsharp

pets <- (Map.add "rob" "dog" pets)

pets.Add("rob", "dog")

fantom

map["rob"] = "dog"

groovy

pets['rob'] = 'dog'

pets.rob = 'dog'

pets.put('rob', 'dog')

haskell

import qualified Data.Map as M

pets = M.insert "rob" "dog" M.empty

Remove an entry from a map

Given a map pets {joe:cat,mary:turtle,bill:canary} remove the mapping for "bill" and print "canary"

python

print pets.pop('bill')

fsharp

let key = "bill"
match (pets |> Map.tryFind key) with
| Some(value) -> pets <- (Map.remove key pets) ; printfn "%s : %s removed" key value
| None -> printfn "Key %s not found" key

let key = "bill"
let entry = if (pets.ContainsKey(key)) then Some(pets.[key]) ; else None
pets.Remove(key)

match entry with
| Some(value) -> printfn "%s" value
| None -> printfn "key not found"

fantom

pet := map.remove("bill")
echo ("pet=$pet")

groovy

pets = [joe:'cat', mary:'turtle', bill:'canary']
println pets.remove('bill')

haskell

import qualified Data.Map as M

main = do
let pets = M.fromList [("joe", "cat"), ("mary", "turtle"), ("bill", "canary")]
pets2 = M.delete "bill" pets
print $ maybe "" id (M.lookup "bill" pets)
print pets2

Algorithms

Create a histogram map from a list

Given the list [a,b,a,c,b,b], produce a map {a:2, b:3, c:1} which contains the count of each unique item in the list

python

from collections import defaultdict
h = defaultdict(int)
for k in "abacbb":
h[k] += 1

h = {}
for k in "abacbb":
h[k] = h.setdefault(k, 0) + 1

from collections import Counter
h = Counter("abacbb")
print(h)

fsharp

let histogram = (List.foldLeft (fun (acc : Map<char, int>) (e : char) -> if (Map.mem e acc) then (Map.add e ((Map.find e acc) + 1) acc) ; else (Map.add e 1 acc)) (Map.empty) list)

let histogram list =
let rec histogram' list' dict' =
match list' with
| [] -> dict'
| x :: xs ->
match Map.tryFind x dict' with
| Some(Value) -> histogram' xs (Map.add x (Value + 1) dict')
| None -> histogram' xs (Map.add x 1 dict')
histogram' list Map.empty

// ------

let histogram' = histogram list

let histogram = (List.foldLeft (fun (acc : Generic.Dictionary<char, int>) (e : char) -> (if acc.ContainsKey(e) then acc.[e] <- acc.[e] + 1 ; else acc.Add(e, 1)) ; acc) (new Generic.Dictionary<char, int>()) list)

let histogram =
list
|> Seq.groupBy (fun a -> a)
|> Seq.map(fun (key, elements) -> key, Seq.length elements)
|> Map.ofSeq

fantom

list := ["a","b","a","c","b","b"]
map := [Str:Int][:]
list.each |Str s, Int i| { if(!map.containsKey(s)) map.add(s,1); else map[s] = ++map[s] }
echo (map)

groovy

histogram = [:]
list.each { item ->
if (!histogram.containsKey(item)) histogram[item] = 0
histogram[item]++
}

histogram = [:]
list.each { histogram[it] = (histogram[it] ?: 0) + 1 }

haskell

import Data.List
import qualified Data.Map as Map

histogram :: Ord a => [a] -> Map.Map a Int
histogram xs = Map.fromList [ (head l, length l) | l <- group (sort xs) ]

output :: Map.Map String Int
output = histogram ["a","b","a","c","b","b"]

import Control.Arrow
import Data.List
import qualified Data.Map as Map
import System.Random

histogram :: Ord a => [a] -> Map.Map a Int
histogram = Map.fromList . map (head &&& length) . group . sort

main = print . histogram . take 1000 . randomRs (1::Int, 100) =<< newStdGen

Categorise a list

Given the list [one, two, three, four, five] produce a map {3:[one, two], 4:[four, five], 5:[three]} which sorts elements into map entries based on their length

python

c = defaultdict(list)
for k in ["one", "two", "four", "three", "five"]:
c[len(k)].append(k)

from itertools import groupby
lst = ["one", "two", "four", "three", "five"]
c = dict((k, list(g)) for k,g in
groupby(sorted(lst, key=lambda x: len(x)), key=lambda x: len(x)))
print(c)

fsharp

let catmap = (List.foldLeft (fun (acc : Map<int, List<string> >) (e : string) -> if (Map.mem e.Length acc) then (Map.add e.Length ((Map.find e.Length acc) @ [e]) acc) ; else (Map.add e.Length [e] acc)) (Map.empty) list)

let lengthMap =
["one"; "two"; "three"; "four"; "five"]
|> Seq.groupBy (fun s -> s.Length)
|> Seq.map (fun (length, entries) -> (length, entries |> List.ofSeq))
|> Map.ofSeq

fantom

list := ["one", "two", "three", "four", "five"]
map := [Int:List][:]
list.each { List l := map[it.size] ?: [,]; map[it.size] = l.add(it) }
echo(map)

groovy

map = ['one', 'two', 'three', 'four', 'five'].groupBy{ it.size() }

haskell

import qualified Data.Map as Map

groupInMapBy :: Ord k => (a -> k) -> [a] -> Map.Map k [a]
groupInMapBy f = foldr (\a -> Map.insertWith (++) (f a) [a]) Map.empty

output :: Map.Map Int [String]
output = groupInMapBy length ["one", "two", "three", "four", "five"]

import Data.List (groupBy, sortBy)
import Data.Function (on)

groupInPairsBy :: Ord k => (a -> k) -> [a] -> [(k, [a])]
groupInPairsBy f = map (\xs -> (f (head xs), xs)) .
groupBy ((==) `on` f) . sortBy (compare `on` f)

output :: [(Int, [String])]
output = groupInPairsBy length ["one", "two", "three", "four", "five"]