langref.org - fsharp, fantom, and groovy

View Category

Maps

Declaration

Define an empty 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();

Define an unmodifiable empty map

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

Define an initial map

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

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

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"

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'

Retrieve a value from a map

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

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'

Add an entry to a map

Given an empty pets map, add the mapping from "rob" to "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')

Remove an entry from a map

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

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

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

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 }

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

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() }